bplusplus 0.1.1__py3-none-any.whl → 1.1.0__py3-none-any.whl

bplusplus/yolov5detect/utils/loggers/comet/hpo.py

@@ -0,0 +1,126 @@
+# Ultralytics YOLOv5 🚀, AGPL-3.0 license
+
+import argparse
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+
+import comet_ml
+
+logger = logging.getLogger(__name__)
+
+FILE = Path(__file__).resolve()
+ROOT = FILE.parents[3]  # YOLOv5 root directory
+if str(ROOT) not in sys.path:
+    sys.path.append(str(ROOT))  # add ROOT to PATH
+
+from train import train
+from utils.callbacks import Callbacks
+from utils.general import increment_path
+from utils.torch_utils import select_device
+
+# Project Configuration
+config = comet_ml.config.get_config()
+COMET_PROJECT_NAME = config.get_string(os.getenv("COMET_PROJECT_NAME"), "comet.project_name", default="yolov5")
+
+
+def get_args(known=False):
+    """Parses command-line arguments for YOLOv5 training, supporting configuration of weights, data paths,
+    hyperparameters, and more.
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--weights", type=str, default=ROOT / "yolov5s.pt", help="initial weights path")
+    parser.add_argument("--cfg", type=str, default="", help="model.yaml path")
+    parser.add_argument("--data", type=str, default=ROOT / "data/coco128.yaml", help="dataset.yaml path")
+    parser.add_argument("--hyp", type=str, default=ROOT / "data/hyps/hyp.scratch-low.yaml", help="hyperparameters path")
+    parser.add_argument("--epochs", type=int, default=300, help="total training epochs")
+    parser.add_argument("--batch-size", type=int, default=16, help="total batch size for all GPUs, -1 for autobatch")
+    parser.add_argument("--imgsz", "--img", "--img-size", type=int, default=640, help="train, val image size (pixels)")
+    parser.add_argument("--rect", action="store_true", help="rectangular training")
+    parser.add_argument("--resume", nargs="?", const=True, default=False, help="resume most recent training")
+    parser.add_argument("--nosave", action="store_true", help="only save final checkpoint")
+    parser.add_argument("--noval", action="store_true", help="only validate final epoch")
+    parser.add_argument("--noautoanchor", action="store_true", help="disable AutoAnchor")
+    parser.add_argument("--noplots", action="store_true", help="save no plot files")
+    parser.add_argument("--evolve", type=int, nargs="?", const=300, help="evolve hyperparameters for x generations")
+    parser.add_argument("--bucket", type=str, default="", help="gsutil bucket")
+    parser.add_argument("--cache", type=str, nargs="?", const="ram", help='--cache images in "ram" (default) or "disk"')
+    parser.add_argument("--image-weights", action="store_true", help="use weighted image selection for training")
+    parser.add_argument("--device", default="", help="cuda device, i.e. 0 or 0,1,2,3 or cpu")
+    parser.add_argument("--multi-scale", action="store_true", help="vary img-size +/- 50%%")
+    parser.add_argument("--single-cls", action="store_true", help="train multi-class data as single-class")
+    parser.add_argument("--optimizer", type=str, choices=["SGD", "Adam", "AdamW"], default="SGD", help="optimizer")
+    parser.add_argument("--sync-bn", action="store_true", help="use SyncBatchNorm, only available in DDP mode")
+    parser.add_argument("--workers", type=int, default=8, help="max dataloader workers (per RANK in DDP mode)")
+    parser.add_argument("--project", default=ROOT / "runs/train", help="save to project/name")
+    parser.add_argument("--name", default="exp", help="save to project/name")
+    parser.add_argument("--exist-ok", action="store_true", help="existing project/name ok, do not increment")
+    parser.add_argument("--quad", action="store_true", help="quad dataloader")
+    parser.add_argument("--cos-lr", action="store_true", help="cosine LR scheduler")
+    parser.add_argument("--label-smoothing", type=float, default=0.0, help="Label smoothing epsilon")
+    parser.add_argument("--patience", type=int, default=100, help="EarlyStopping patience (epochs without improvement)")
+    parser.add_argument("--freeze", nargs="+", type=int, default=[0], help="Freeze layers: backbone=10, first3=0 1 2")
+    parser.add_argument("--save-period", type=int, default=-1, help="Save checkpoint every x epochs (disabled if < 1)")
+    parser.add_argument("--seed", type=int, default=0, help="Global training seed")
+    parser.add_argument("--local_rank", type=int, default=-1, help="Automatic DDP Multi-GPU argument, do not modify")
+
+    # Weights & Biases arguments
+    parser.add_argument("--entity", default=None, help="W&B: Entity")
+    parser.add_argument("--upload_dataset", nargs="?", const=True, default=False, help='W&B: Upload data, "val" option')
+    parser.add_argument("--bbox_interval", type=int, default=-1, help="W&B: Set bounding-box image logging interval")
+    parser.add_argument("--artifact_alias", type=str, default="latest", help="W&B: Version of dataset artifact to use")
+
+    # Comet Arguments
+    parser.add_argument("--comet_optimizer_config", type=str, help="Comet: Path to a Comet Optimizer Config File.")
+    parser.add_argument("--comet_optimizer_id", type=str, help="Comet: ID of the Comet Optimizer sweep.")
+    parser.add_argument("--comet_optimizer_objective", type=str, help="Comet: Set to 'minimize' or 'maximize'.")
+    parser.add_argument("--comet_optimizer_metric", type=str, help="Comet: Metric to Optimize.")
+    parser.add_argument(
+        "--comet_optimizer_workers",
+        type=int,
+        default=1,
+        help="Comet: Number of Parallel Workers to use with the Comet Optimizer.",
+    )
+
+    return parser.parse_known_args()[0] if known else parser.parse_args()
+
+
+def run(parameters, opt):
+    """Executes YOLOv5 training with given hyperparameters and options, setting up device and training directories."""
+    hyp_dict = {k: v for k, v in parameters.items() if k not in ["epochs", "batch_size"]}
+
+    opt.save_dir = str(increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok or opt.evolve))
+    opt.batch_size = parameters.get("batch_size")
+    opt.epochs = parameters.get("epochs")
+
+    device = select_device(opt.device, batch_size=opt.batch_size)
+    train(hyp_dict, opt, device, callbacks=Callbacks())
+
+
+if __name__ == "__main__":
+    opt = get_args(known=True)
+
+    opt.weights = str(opt.weights)
+    opt.cfg = str(opt.cfg)
+    opt.data = str(opt.data)
+    opt.project = str(opt.project)
+
+    optimizer_id = os.getenv("COMET_OPTIMIZER_ID")
+    if optimizer_id is None:
+        with open(opt.comet_optimizer_config) as f:
+            optimizer_config = json.load(f)
+        optimizer = comet_ml.Optimizer(optimizer_config)
+    else:
+        optimizer = comet_ml.Optimizer(optimizer_id)
+
+    opt.comet_optimizer_id = optimizer.id
+    status = optimizer.status()
+
+    opt.comet_optimizer_objective = status["spec"]["objective"]
+    opt.comet_optimizer_metric = status["spec"]["metric"]
+
+    logger.info("COMET INFO: Starting Hyperparameter Sweep")
+    for parameter in optimizer.get_parameters():
+        run(parameter["parameters"], opt)

bplusplus/yolov5detect/utils/loggers/comet/optimizer_config.json

@@ -0,0 +1,135 @@
+{
+  "algorithm": "random",
+  "parameters": {
+    "anchor_t": {
+      "type": "discrete",
+      "values": [2, 8]
+    },
+    "batch_size": {
+      "type": "discrete",
+      "values": [16, 32, 64]
+    },
+    "box": {
+      "type": "discrete",
+      "values": [0.02, 0.2]
+    },
+    "cls": {
+      "type": "discrete",
+      "values": [0.2]
+    },
+    "cls_pw": {
+      "type": "discrete",
+      "values": [0.5]
+    },
+    "copy_paste": {
+      "type": "discrete",
+      "values": [1]
+    },
+    "degrees": {
+      "type": "discrete",
+      "values": [0, 45]
+    },
+    "epochs": {
+      "type": "discrete",
+      "values": [5]
+    },
+    "fl_gamma": {
+      "type": "discrete",
+      "values": [0]
+    },
+    "fliplr": {
+      "type": "discrete",
+      "values": [0]
+    },
+    "flipud": {
+      "type": "discrete",
+      "values": [0]
+    },
+    "hsv_h": {
+      "type": "discrete",
+      "values": [0]
+    },
+    "hsv_s": {
+      "type": "discrete",
+      "values": [0]
+    },
+    "hsv_v": {
+      "type": "discrete",
+      "values": [0]
+    },
+    "iou_t": {
+      "type": "discrete",
+      "values": [0.7]
+    },
+    "lr0": {
+      "type": "discrete",
+      "values": [1e-5, 0.1]
+    },
+    "lrf": {
+      "type": "discrete",
+      "values": [0.01, 1]
+    },
+    "mixup": {
+      "type": "discrete",
+      "values": [1]
+    },
+    "momentum": {
+      "type": "discrete",
+      "values": [0.6]
+    },
+    "mosaic": {
+      "type": "discrete",
+      "values": [0]
+    },
+    "obj": {
+      "type": "discrete",
+      "values": [0.2]
+    },
+    "obj_pw": {
+      "type": "discrete",
+      "values": [0.5]
+    },
+    "optimizer": {
+      "type": "categorical",
+      "values": ["SGD", "Adam", "AdamW"]
+    },
+    "perspective": {
+      "type": "discrete",
+      "values": [0]
+    },
+    "scale": {
+      "type": "discrete",
+      "values": [0]
+    },
+    "shear": {
+      "type": "discrete",
+      "values": [0]
+    },
+    "translate": {
+      "type": "discrete",
+      "values": [0]
+    },
+    "warmup_bias_lr": {
+      "type": "discrete",
+      "values": [0, 0.2]
+    },
+    "warmup_epochs": {
+      "type": "discrete",
+      "values": [5]
+    },
+    "warmup_momentum": {
+      "type": "discrete",
+      "values": [0, 0.95]
+    },
+    "weight_decay": {
+      "type": "discrete",
+      "values": [0, 0.001]
+    }
+  },
+  "spec": {
+    "maxCombo": 0,
+    "metric": "metrics/mAP_0.5",
+    "objective": "maximize"
+  },
+  "trials": 1
+}

bplusplus/yolov5detect/utils/loggers/wandb/wandb_utils.py

@@ -0,0 +1,210 @@
+# Ultralytics YOLOv5 🚀, AGPL-3.0 license
+
+# WARNING ⚠️ wandb is deprecated and will be removed in future release.
+# See supported integrations at https://github.com/ultralytics/yolov5#integrations
+
+import logging
+import os
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+
+from utils.general import LOGGER, colorstr
+
+FILE = Path(__file__).resolve()
+ROOT = FILE.parents[3]  # YOLOv5 root directory
+if str(ROOT) not in sys.path:
+    sys.path.append(str(ROOT))  # add ROOT to PATH
+RANK = int(os.getenv("RANK", -1))
+DEPRECATION_WARNING = (
+    f"{colorstr('wandb')}: WARNING ⚠️ wandb is deprecated and will be removed in a future release. "
+    f'See supported integrations at https://github.com/ultralytics/yolov5#integrations.'
+)
+
+try:
+    import wandb
+
+    assert hasattr(wandb, "__version__")  # verify package import not local dir
+    LOGGER.warning(DEPRECATION_WARNING)
+except (ImportError, AssertionError):
+    wandb = None
+
+
+class WandbLogger:
+    """
+    Log training runs, datasets, models, and predictions to Weights & Biases.
+
+    This logger sends information to W&B at wandb.ai. By default, this information includes hyperparameters, system
+    configuration and metrics, model metrics, and basic data metrics and analyses.
+
+    By providing additional command line arguments to train.py, datasets, models and predictions can also be logged.
+
+    For more on how this logger is used, see the Weights & Biases documentation:
+    https://docs.wandb.com/guides/integrations/yolov5
+    """
+
+    def __init__(self, opt, run_id=None, job_type="Training"):
+        """
+        - Initialize WandbLogger instance
+        - Upload dataset if opt.upload_dataset is True
+        - Setup training processes if job_type is 'Training'.
+
+        Arguments:
+        opt (namespace) -- Commandline arguments for this run
+        run_id (str) -- Run ID of W&B run to be resumed
+        job_type (str) -- To set the job_type for this run
+
+        """
+        # Pre-training routine --
+        self.job_type = job_type
+        self.wandb, self.wandb_run = wandb, wandb.run if wandb else None
+        self.val_artifact, self.train_artifact = None, None
+        self.train_artifact_path, self.val_artifact_path = None, None
+        self.result_artifact = None
+        self.val_table, self.result_table = None, None
+        self.max_imgs_to_log = 16
+        self.data_dict = None
+        if self.wandb:
+            self.wandb_run = wandb.run or wandb.init(
+                config=opt,
+                resume="allow",
+                project="YOLOv5" if opt.project == "runs/train" else Path(opt.project).stem,
+                entity=opt.entity,
+                name=opt.name if opt.name != "exp" else None,
+                job_type=job_type,
+                id=run_id,
+                allow_val_change=True,
+            )
+
+        if self.wandb_run and self.job_type == "Training":
+            if isinstance(opt.data, dict):
+                # This means another dataset manager has already processed the dataset info (e.g. ClearML)
+                # and they will have stored the already processed dict in opt.data
+                self.data_dict = opt.data
+            self.setup_training(opt)
+
+    def setup_training(self, opt):
+        """
+        Setup the necessary processes for training YOLO models:
+          - Attempt to download model checkpoint and dataset artifacts if opt.resume stats with WANDB_ARTIFACT_PREFIX
+          - Update data_dict, to contain info of previous run if resumed and the paths of dataset artifact if downloaded
+          - Setup log_dict, initialize bbox_interval.
+
+        Arguments:
+        opt (namespace) -- commandline arguments for this run
+
+        """
+        self.log_dict, self.current_epoch = {}, 0
+        self.bbox_interval = opt.bbox_interval
+        if isinstance(opt.resume, str):
+            model_dir, _ = self.download_model_artifact(opt)
+            if model_dir:
+                self.weights = Path(model_dir) / "last.pt"
+                config = self.wandb_run.config
+                opt.weights, opt.save_period, opt.batch_size, opt.bbox_interval, opt.epochs, opt.hyp, opt.imgsz = (
+                    str(self.weights),
+                    config.save_period,
+                    config.batch_size,
+                    config.bbox_interval,
+                    config.epochs,
+                    config.hyp,
+                    config.imgsz,
+                )
+
+        if opt.bbox_interval == -1:
+            self.bbox_interval = opt.bbox_interval = (opt.epochs // 10) if opt.epochs > 10 else 1
+            if opt.evolve or opt.noplots:
+                self.bbox_interval = opt.bbox_interval = opt.epochs + 1  # disable bbox_interval
+
+    def log_model(self, path, opt, epoch, fitness_score, best_model=False):
+        """
+        Log the model checkpoint as W&B artifact.
+
+        Arguments:
+        path (Path)   -- Path of directory containing the checkpoints
+        opt (namespace) -- Command line arguments for this run
+        epoch (int)  -- Current epoch number
+        fitness_score (float) -- fitness score for current epoch
+        best_model (boolean) -- Boolean representing if the current checkpoint is the best yet.
+        """
+        model_artifact = wandb.Artifact(
+            f"run_{wandb.run.id}_model",
+            type="model",
+            metadata={
+                "original_url": str(path),
+                "epochs_trained": epoch + 1,
+                "save period": opt.save_period,
+                "project": opt.project,
+                "total_epochs": opt.epochs,
+                "fitness_score": fitness_score,
+            },
+        )
+        model_artifact.add_file(str(path / "last.pt"), name="last.pt")
+        wandb.log_artifact(
+            model_artifact,
+            aliases=[
+                "latest",
+                "last",
+                f"epoch {str(self.current_epoch)}",
+                "best" if best_model else "",
+            ],
+        )
+        LOGGER.info(f"Saving model artifact on epoch {epoch + 1}")
+
+    def val_one_image(self, pred, predn, path, names, im):
+        """Evaluates model prediction for a single image, returning metrics and visualizations."""
+        pass
+
+    def log(self, log_dict):
+        """
+        Save the metrics to the logging dictionary.
+
+        Arguments:
+        log_dict (Dict) -- metrics/media to be logged in current step
+        """
+        if self.wandb_run:
+            for key, value in log_dict.items():
+                self.log_dict[key] = value
+
+    def end_epoch(self):
+        """
+        Commit the log_dict, model artifacts and Tables to W&B and flush the log_dict.
+
+        Arguments:
+        best_result (boolean): Boolean representing if the result of this evaluation is best or not
+        """
+        if self.wandb_run:
+            with all_logging_disabled():
+                try:
+                    wandb.log(self.log_dict)
+                except BaseException as e:
+                    LOGGER.info(
+                        f"An error occurred in wandb logger. The training will proceed without interruption. More info\n{e}"
+                    )
+                    self.wandb_run.finish()
+                    self.wandb_run = None
+                self.log_dict = {}
+
+    def finish_run(self):
+        """Log metrics if any and finish the current W&B run."""
+        if self.wandb_run:
+            if self.log_dict:
+                with all_logging_disabled():
+                    wandb.log(self.log_dict)
+            wandb.run.finish()
+            LOGGER.warning(DEPRECATION_WARNING)
+
+
+@contextmanager
+def all_logging_disabled(highest_level=logging.CRITICAL):
+    """Source - https://gist.github.com/simon-weber/7853144
+    A context manager that will prevent any logging messages triggered during the body from being processed.
+    :param highest_level: the maximum logging level in use.
+      This would only need to be changed if a custom level greater than CRITICAL is defined.
+    """
+    previous_level = logging.root.manager.disable
+    logging.disable(highest_level)
+    try:
+        yield
+    finally:
+        logging.disable(previous_level)