oracle_context_cache/MultimediaTechLab__YOLO.json

{"repo": "MultimediaTechLab/YOLO", "n_pairs": 46, "version": "v2_function_scoped", "contexts": {"tests/test_model/test_yolo.py::66": {"resolved_imports": ["yolo/config/config.py", "yolo/model/yolo.py"], "used_names": ["YOLO"], "enclosing_function": "test_model_basic_status", "extracted_code": "# Source: yolo/model/yolo.py\nclass YOLO(nn.Module):\n    \"\"\"\n    A preliminary YOLO (You Only Look Once) model class still under development.\n\n    Parameters:\n        model_cfg: Configuration for the YOLO model. Expected to define the layers,\n                   parameters, and any other relevant configuration details.\n    \"\"\"\n\n    def __init__(self, model_cfg: ModelConfig, class_num: int = 80):\n        super(YOLO, self).__init__()\n        self.num_classes = class_num\n        self.layer_map = get_layer_map()  # Get the map Dict[str: Module]\n        self.model: List[YOLOLayer] = nn.ModuleList()\n        self.reg_max = getattr(model_cfg.anchor, \"reg_max\", 16)\n        self.build_model(model_cfg.model)\n\n    def build_model(self, model_arch: Dict[str, List[Dict[str, Dict[str, Dict]]]]):\n        self.layer_index = {}\n        output_dim, layer_idx = [3], 1\n        logger.info(f\":tractor: Building YOLO\")\n        for arch_name in model_arch:\n            if model_arch[arch_name]:\n                logger.info(f\"  :building_construction:  Building {arch_name}\")\n            for layer_idx, layer_spec in enumerate(model_arch[arch_name], start=layer_idx):\n                layer_type, layer_info = next(iter(layer_spec.items()))\n                layer_args = layer_info.get(\"args\", {})\n\n                # Get input source\n                source = self.get_source_idx(layer_info.get(\"source\", -1), layer_idx)\n\n                # Find in channels\n                if any(module in layer_type for module in [\"Conv\", \"ELAN\", \"ADown\", \"AConv\", \"CBLinear\"]):\n                    layer_args[\"in_channels\"] = output_dim[source]\n                if any(module in layer_type for module in [\"Detection\", \"Segmentation\", \"Classification\"]):\n                    if isinstance(source, list):\n                        layer_args[\"in_channels\"] = [output_dim[idx] for idx in source]\n                    else:\n                        layer_args[\"in_channel\"] = output_dim[source]\n                    layer_args[\"num_classes\"] = self.num_classes\n                    layer_args[\"reg_max\"] = self.reg_max\n\n                # create layers\n                layer = self.create_layer(layer_type, source, layer_info, **layer_args)\n                self.model.append(layer)\n\n                if layer.tags:\n                    if layer.tags in self.layer_index:\n                        raise ValueError(f\"Duplicate tag '{layer_info['tags']}' found.\")\n                    self.layer_index[layer.tags] = layer_idx\n\n                out_channels = self.get_out_channels(layer_type, layer_args, output_dim, source)\n                output_dim.append(out_channels)\n                setattr(layer, \"out_c\", out_channels)\n            layer_idx += 1\n\n    def forward(self, x, external: Optional[Dict] = None, shortcut: Optional[str] = None):\n        y = {0: x, **(external or {})}\n        output = dict()\n        for index, layer in enumerate(self.model, start=1):\n            if isinstance(layer.source, list):\n                model_input = [y[idx] for idx in layer.source]\n            else:\n                model_input = y[layer.source]\n\n            external_input = {source_name: y[source_name] for source_name in layer.external}\n\n            x = layer(model_input, **external_input)\n            y[-1] = x\n            if layer.usable:\n                y[index] = x\n            if layer.output:\n                output[layer.tags] = x\n                if layer.tags == shortcut:\n                    return output\n        return output\n\n    def get_out_channels(self, layer_type: str, layer_args: dict, output_dim: list, source: Union[int, list]):\n        if hasattr(layer_args, \"out_channels\"):\n            return layer_args[\"out_channels\"]\n        if layer_type == \"CBFuse\":\n            return output_dim[source[-1]]\n        if isinstance(source, int):\n            return output_dim[source]\n        if isinstance(source, list):\n            return sum(output_dim[idx] for idx in source)\n\n    def get_source_idx(self, source: Union[ListConfig, str, int], layer_idx: int):\n        if isinstance(source, ListConfig):\n            return [self.get_source_idx(index, layer_idx) for index in source]\n        if isinstance(source, str):\n            source = self.layer_index[source]\n        if source < -1:\n            source += layer_idx\n        if source > 0:  # Using Previous Layer's Output\n            self.model[source - 1].usable = True\n        return source\n\n    def create_layer(self, layer_type: str, source: Union[int, list], layer_info: Dict, **kwargs) -> YOLOLayer:\n        if layer_type in self.layer_map:\n            layer = self.layer_map[layer_type](**kwargs)\n            setattr(layer, \"layer_type\", layer_type)\n            setattr(layer, \"source\", source)\n            setattr(layer, \"in_c\", kwargs.get(\"in_channels\", None))\n            setattr(layer, \"output\", layer_info.get(\"output\", False))\n            setattr(layer, \"tags\", layer_info.get(\"tags\", None))\n            setattr(layer, \"external\", layer_info.get(\"external\", []))\n            setattr(layer, \"usable\", 0)\n            return layer\n        else:\n            raise ValueError(f\"Unsupported layer type: {layer_type}\")\n\n    def save_load_weights(self, weights: Union[Path, OrderedDict]):\n        \"\"\"\n        Update the model's weights with the provided weights.\n\n        args:\n            weights: A OrderedDict containing the new weights.\n        \"\"\"\n        if isinstance(weights, Path):\n            weights = torch.load(weights, map_location=torch.device(\"cpu\"), weights_only=False)\n        if \"state_dict\" in weights:\n            weights = {name.removeprefix(\"model.model.\"): key for name, key in weights[\"state_dict\"].items()}\n        model_state_dict = self.model.state_dict()\n\n        # TODO1: autoload old version weight\n        # TODO2: weight transform if num_class difference\n\n        error_dict = {\"Mismatch\": set(), \"Not Found\": set()}\n        for model_key, model_weight in model_state_dict.items():\n            if model_key not in weights:\n                error_dict[\"Not Found\"].add(tuple(model_key.split(\".\")[:-2]))\n                continue\n            if model_weight.shape != weights[model_key].shape:\n                error_dict[\"Mismatch\"].add(tuple(model_key.split(\".\")[:-2]))\n                continue\n            model_state_dict[model_key] = weights[model_key]\n\n        for error_name, error_set in error_dict.items():\n            error_dict = dict()\n            for layer_idx, *layer_name in error_set:\n                if layer_idx not in error_dict:\n                    error_dict[layer_idx] = [\".\".join(layer_name)]\n                else:\n                    error_dict[layer_idx].append(\".\".join(layer_name))\n            for layer_idx, layer_name in error_dict.items():\n                layer_name.sort()\n                logger.warning(f\":warning: Weight {error_name} for Layer {layer_idx}: {', '.join(layer_name)}\")\n\n        self.model.load_state_dict(model_state_dict)", "n_imports_parsed": 8, "n_files_resolved": 2, "n_chars_extracted": 6918}, "tests/test_tools/test_data_loader.py::48": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["DataLoader", "Path"], "enclosing_function": "test_validation_data_loader_correctness", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_tools/test_data_loader.py::33": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["DataLoader", "Path"], "enclosing_function": "test_training_data_loader_correctness", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_model/test_module.py::51": {"resolved_imports": ["yolo/model/module.py"], "used_names": ["CBLinear", "torch"], "enclosing_function": "test_cblinear", "extracted_code": "# Source: yolo/model/module.py\nclass CBLinear(nn.Module):\n    \"\"\"Convolutional block that outputs multiple feature maps split along the channel dimension.\"\"\"\n\n    def __init__(self, in_channels: int, out_channels: List[int], kernel_size: int = 1, **kwargs):\n        super(CBLinear, self).__init__()\n        kwargs.setdefault(\"padding\", auto_pad(kernel_size, **kwargs))\n        self.conv = nn.Conv2d(in_channels, sum(out_channels), kernel_size, **kwargs)\n        self.out_channels = list(out_channels)\n\n    def forward(self, x: Tensor) -> Tuple[Tensor]:\n        x = self.conv(x)\n        return x.split(self.out_channels, dim=1)", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 626}, "tests/test_utils/test_bounding_box_utils.py::37": {"resolved_imports": ["yolo/__init__.py", "yolo/config/config.py", "yolo/utils/bounding_box_utils.py"], "used_names": ["allclose", "calculate_iou", "tensor"], "enclosing_function": "test_calculate_iou_2d", "extracted_code": "# Source: yolo/utils/bounding_box_utils.py\ndef calculate_iou(bbox1, bbox2, metrics=\"iou\") -> Tensor:\n    metrics = metrics.lower()\n    EPS = 1e-7\n    dtype = bbox1.dtype\n    bbox1 = bbox1.to(torch.float32)\n    bbox2 = bbox2.to(torch.float32)\n\n    # Expand dimensions if necessary\n    if bbox1.ndim == 2 and bbox2.ndim == 2:\n        bbox1 = bbox1.unsqueeze(1)  # (Ax4) -> (Ax1x4)\n        bbox2 = bbox2.unsqueeze(0)  # (Bx4) -> (1xBx4)\n    elif bbox1.ndim == 3 and bbox2.ndim == 3:\n        bbox1 = bbox1.unsqueeze(2)  # (BZxAx4) -> (BZxAx1x4)\n        bbox2 = bbox2.unsqueeze(1)  # (BZxBx4) -> (BZx1xBx4)\n\n    # Calculate intersection coordinates\n    xmin_inter = torch.max(bbox1[..., 0], bbox2[..., 0])\n    ymin_inter = torch.max(bbox1[..., 1], bbox2[..., 1])\n    xmax_inter = torch.min(bbox1[..., 2], bbox2[..., 2])\n    ymax_inter = torch.min(bbox1[..., 3], bbox2[..., 3])\n\n    # Calculate intersection area\n    intersection_area = torch.clamp(xmax_inter - xmin_inter, min=0) * torch.clamp(ymax_inter - ymin_inter, min=0)\n\n    # Calculate area of each bbox\n    area_bbox1 = (bbox1[..., 2] - bbox1[..., 0]) * (bbox1[..., 3] - bbox1[..., 1])\n    area_bbox2 = (bbox2[..., 2] - bbox2[..., 0]) * (bbox2[..., 3] - bbox2[..., 1])\n\n    # Calculate union area\n    union_area = area_bbox1 + area_bbox2 - intersection_area\n\n    # Calculate IoU\n    iou = intersection_area / (union_area + EPS)\n    if metrics == \"iou\":\n        return iou.to(dtype)\n\n    # Calculate centroid distance\n    cx1 = (bbox1[..., 2] + bbox1[..., 0]) / 2\n    cy1 = (bbox1[..., 3] + bbox1[..., 1]) / 2\n    cx2 = (bbox2[..., 2] + bbox2[..., 0]) / 2\n    cy2 = (bbox2[..., 3] + bbox2[..., 1]) / 2\n    cent_dis = (cx1 - cx2) ** 2 + (cy1 - cy2) ** 2\n\n    # Calculate diagonal length of the smallest enclosing box\n    c_x = torch.max(bbox1[..., 2], bbox2[..., 2]) - torch.min(bbox1[..., 0], bbox2[..., 0])\n    c_y = torch.max(bbox1[..., 3], bbox2[..., 3]) - torch.min(bbox1[..., 1], bbox2[..., 1])\n    diag_dis = c_x**2 + c_y**2 + EPS\n\n    diou = iou - (cent_dis / diag_dis)\n    if metrics == \"diou\":\n        return diou.to(dtype)\n\n    # Compute aspect ratio penalty term\n    arctan = torch.atan((bbox1[..., 2] - bbox1[..., 0]) / (bbox1[..., 3] - bbox1[..., 1] + EPS)) - torch.atan(\n        (bbox2[..., 2] - bbox2[..., 0]) / (bbox2[..., 3] - bbox2[..., 1] + EPS)\n    )\n    v = (4 / (math.pi**2)) * (arctan**2)\n    with torch.no_grad():\n        alpha = v / (v - iou + 1 + EPS)\n    # Compute CIoU\n    ciou = diou - alpha * v\n    return ciou.to(dtype)", "n_imports_parsed": 9, "n_files_resolved": 3, "n_chars_extracted": 2502}, "tests/test_tools/test_data_loader.py::27": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["Config", "Path", "create_dataloader"], "enclosing_function": "test_create_dataloader_cache", "extracted_code": "# Source: yolo/config/config.py\nclass Config:\n    task: Union[TrainConfig, InferenceConfig, ValidationConfig]\n    dataset: DatasetConfig\n    model: ModelConfig\n    name: str\n\n    accelerator: Optional[str]\n    device: Union[str, int, List[int]]\n    cpu_num: int\n\n    image_size: List[int]\n\n    out_path: str\n    exist_ok: bool\n\n    lucky_number: 10\n    use_wandb: bool\n    use_tensorboard: bool\n\n    weight: Optional[str]\n\n\n# Source: yolo/tools/data_loader.py\ndef create_dataloader(data_cfg: DataConfig, dataset_cfg: DatasetConfig, task: str = \"train\"):\n    if task == \"inference\":\n        return StreamDataLoader(data_cfg)\n\n    if getattr(dataset_cfg, \"auto_download\", False):\n        prepare_dataset(dataset_cfg, task)\n    dataset = YoloDataset(data_cfg, dataset_cfg, task)\n\n    return DataLoader(\n        dataset,\n        batch_size=data_cfg.batch_size,\n        num_workers=data_cfg.cpu_num,\n        pin_memory=data_cfg.pin_memory,\n        collate_fn=collate_fn,\n    )", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 971}, "tests/test_model/test_module.py::43": {"resolved_imports": ["yolo/model/module.py"], "used_names": ["ADown", "torch"], "enclosing_function": "test_adown", "extracted_code": "# Source: yolo/model/module.py\nclass ADown(nn.Module):\n    \"\"\"Downsampling module combining average and max pooling with convolution for feature reduction.\"\"\"\n\n    def __init__(self, in_channels: int, out_channels: int):\n        super().__init__()\n        half_in_channels = in_channels // 2\n        half_out_channels = out_channels // 2\n        mid_layer = {\"kernel_size\": 3, \"stride\": 2}\n        self.avg_pool = Pool(\"avg\", kernel_size=2, stride=1)\n        self.conv1 = Conv(half_in_channels, half_out_channels, **mid_layer)\n        self.max_pool = Pool(\"max\", **mid_layer)\n        self.conv2 = Conv(half_in_channels, half_out_channels, kernel_size=1)\n\n    def forward(self, x: Tensor) -> Tensor:\n        x = self.avg_pool(x)\n        x1, x2 = x.chunk(2, dim=1)\n        x1 = self.conv1(x1)\n        x2 = self.max_pool(x2)\n        x2 = self.conv2(x2)\n        return torch.cat((x1, x2), dim=1)", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 891}, "tests/test_utils/test_bounding_box_utils.py::145": {"resolved_imports": ["yolo/__init__.py", "yolo/config/config.py", "yolo/utils/bounding_box_utils.py"], "used_names": ["Anc2Box", "AnchorConfig", "Config", "create_model", "torch"], "enclosing_function": "test_anc2box_autoanchor", "extracted_code": "# Source: yolo/__init__.py\nfrom yolo.config.config import Config, NMSConfig\nfrom yolo.model.yolo import create_model\nfrom yolo.tools.data_loader import AugmentationComposer, create_dataloader\nfrom yolo.tools.drawer import draw_bboxes\nfrom yolo.tools.solver import TrainModel\nfrom yolo.utils.bounding_box_utils import Anc2Box, Vec2Box, bbox_nms, create_converter\nfrom yolo.utils.deploy_utils import FastModelLoader\nfrom yolo.utils.logging_utils import (\n    ImageLogger,\n    YOLORichModelSummary,\n\nfrom yolo.config.config import Config, NMSConfig\nfrom yolo.model.yolo import create_model\nfrom yolo.tools.data_loader import AugmentationComposer, create_dataloader\nfrom yolo.tools.drawer import draw_bboxes\nfrom yolo.tools.solver import TrainModel\nfrom yolo.utils.bounding_box_utils import Anc2Box, Vec2Box, bbox_nms, create_converter\nfrom yolo.utils.deploy_utils import FastModelLoader\nfrom yolo.utils.logging_utils import (\n    ImageLogger,\n    YOLORichModelSummary,\n    YOLORichProgressBar,\n\n\nall = [\n    \"create_model\",\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n\nall = [\n    \"create_model\",\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n    \"create_converter\",\n\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n    \"create_converter\",\n    \"AugmentationComposer\",\n    \"ImageLogger\",\n\n\n# Source: yolo/config/config.py\nclass AnchorConfig:\n    strides: List[int]\n    reg_max: Optional[int]\n    anchor_num: Optional[int]\n    anchor: List[List[int]]\n\n\n# Source: yolo/utils/bounding_box_utils.py\nclass Anc2Box:\n    def __init__(self, model: YOLO, anchor_cfg: AnchorConfig, image_size, device):\n        self.device = device\n\n        if hasattr(anchor_cfg, \"strides\"):\n            logger.info(f\":japanese_not_free_of_charge_button: Found stride of model {anchor_cfg.strides}\")\n            self.strides = anchor_cfg.strides\n        else:\n            logger.info(\":teddy_bear: Found no stride of model, performed a dummy test for auto-anchor size\")\n            self.strides = self.create_auto_anchor(model, image_size)\n\n        self.head_num = len(anchor_cfg.anchor)\n        self.anchor_grids = self.generate_anchors(image_size)\n        self.anchor_scale = tensor(anchor_cfg.anchor, device=device).view(self.head_num, 1, -1, 1, 1, 2)\n        self.anchor_num = self.anchor_scale.size(2)\n        self.class_num = model.num_classes\n\n    def create_auto_anchor(self, model: YOLO, image_size):\n        W, H = image_size\n        dummy_input = torch.zeros(1, 3, H, W).to(self.device)\n        dummy_output = model(dummy_input)\n        strides = []\n        for predict_head in dummy_output[\"Main\"]:\n            _, _, *anchor_num = predict_head.shape\n            strides.append(W // anchor_num[1])\n        return strides\n\n    def generate_anchors(self, image_size: List[int]):\n        anchor_grids = []\n        for stride in self.strides:\n            W, H = image_size[0] // stride, image_size[1] // stride\n            anchor_h, anchor_w = torch.meshgrid([torch.arange(H), torch.arange(W)], indexing=\"ij\")\n            anchor_grid = torch.stack((anchor_w, anchor_h), 2).view((1, 1, H, W, 2)).float().to(self.device)\n            anchor_grids.append(anchor_grid)\n        return anchor_grids\n\n    def update(self, image_size):\n        self.anchor_grids = self.generate_anchors(image_size)\n\n    def __call__(self, predicts: List[Tensor]):\n        preds_box, preds_cls, preds_cnf = [], [], []\n        for layer_idx, predict in enumerate(predicts):\n            predict = rearrange(predict, \"B (L C) h w -> B L h w C\", L=self.anchor_num)\n            pred_box, pred_cnf, pred_cls = predict.split((4, 1, self.class_num), dim=-1)\n            pred_box = pred_box.sigmoid()\n            pred_box[..., 0:2] = (pred_box[..., 0:2] * 2.0 - 0.5 + self.anchor_grids[layer_idx]) * self.strides[\n                layer_idx\n            ]\n            pred_box[..., 2:4] = (pred_box[..., 2:4] * 2) ** 2 * self.anchor_scale[layer_idx]\n            preds_box.append(rearrange(pred_box, \"B L h w A -> B (L h w) A\"))\n            preds_cls.append(rearrange(pred_cls, \"B L h w C -> B (L h w) C\"))\n            preds_cnf.append(rearrange(pred_cnf, \"B L h w C -> B (L h w) C\"))\n\n        preds_box = torch.concat(preds_box, dim=1)\n        preds_cls = torch.concat(preds_cls, dim=1)\n        preds_cnf = torch.concat(preds_cnf, dim=1)\n\n        preds_box = transform_bbox(preds_box, \"xycwh -> xyxy\")\n        return preds_cls, None, preds_box, preds_cnf.sigmoid()", "n_imports_parsed": 9, "n_files_resolved": 3, "n_chars_extracted": 4808}, "tests/test_utils/test_bounding_box_utils.py::45": {"resolved_imports": ["yolo/__init__.py", "yolo/config/config.py", "yolo/utils/bounding_box_utils.py"], "used_names": ["allclose", "calculate_iou", "tensor"], "enclosing_function": "test_calculate_iou_3d", "extracted_code": "# Source: yolo/utils/bounding_box_utils.py\ndef calculate_iou(bbox1, bbox2, metrics=\"iou\") -> Tensor:\n    metrics = metrics.lower()\n    EPS = 1e-7\n    dtype = bbox1.dtype\n    bbox1 = bbox1.to(torch.float32)\n    bbox2 = bbox2.to(torch.float32)\n\n    # Expand dimensions if necessary\n    if bbox1.ndim == 2 and bbox2.ndim == 2:\n        bbox1 = bbox1.unsqueeze(1)  # (Ax4) -> (Ax1x4)\n        bbox2 = bbox2.unsqueeze(0)  # (Bx4) -> (1xBx4)\n    elif bbox1.ndim == 3 and bbox2.ndim == 3:\n        bbox1 = bbox1.unsqueeze(2)  # (BZxAx4) -> (BZxAx1x4)\n        bbox2 = bbox2.unsqueeze(1)  # (BZxBx4) -> (BZx1xBx4)\n\n    # Calculate intersection coordinates\n    xmin_inter = torch.max(bbox1[..., 0], bbox2[..., 0])\n    ymin_inter = torch.max(bbox1[..., 1], bbox2[..., 1])\n    xmax_inter = torch.min(bbox1[..., 2], bbox2[..., 2])\n    ymax_inter = torch.min(bbox1[..., 3], bbox2[..., 3])\n\n    # Calculate intersection area\n    intersection_area = torch.clamp(xmax_inter - xmin_inter, min=0) * torch.clamp(ymax_inter - ymin_inter, min=0)\n\n    # Calculate area of each bbox\n    area_bbox1 = (bbox1[..., 2] - bbox1[..., 0]) * (bbox1[..., 3] - bbox1[..., 1])\n    area_bbox2 = (bbox2[..., 2] - bbox2[..., 0]) * (bbox2[..., 3] - bbox2[..., 1])\n\n    # Calculate union area\n    union_area = area_bbox1 + area_bbox2 - intersection_area\n\n    # Calculate IoU\n    iou = intersection_area / (union_area + EPS)\n    if metrics == \"iou\":\n        return iou.to(dtype)\n\n    # Calculate centroid distance\n    cx1 = (bbox1[..., 2] + bbox1[..., 0]) / 2\n    cy1 = (bbox1[..., 3] + bbox1[..., 1]) / 2\n    cx2 = (bbox2[..., 2] + bbox2[..., 0]) / 2\n    cy2 = (bbox2[..., 3] + bbox2[..., 1]) / 2\n    cent_dis = (cx1 - cx2) ** 2 + (cy1 - cy2) ** 2\n\n    # Calculate diagonal length of the smallest enclosing box\n    c_x = torch.max(bbox1[..., 2], bbox2[..., 2]) - torch.min(bbox1[..., 0], bbox2[..., 0])\n    c_y = torch.max(bbox1[..., 3], bbox2[..., 3]) - torch.min(bbox1[..., 1], bbox2[..., 1])\n    diag_dis = c_x**2 + c_y**2 + EPS\n\n    diou = iou - (cent_dis / diag_dis)\n    if metrics == \"diou\":\n        return diou.to(dtype)\n\n    # Compute aspect ratio penalty term\n    arctan = torch.atan((bbox1[..., 2] - bbox1[..., 0]) / (bbox1[..., 3] - bbox1[..., 1] + EPS)) - torch.atan(\n        (bbox2[..., 2] - bbox2[..., 0]) / (bbox2[..., 3] - bbox2[..., 1] + EPS)\n    )\n    v = (4 / (math.pi**2)) * (arctan**2)\n    with torch.no_grad():\n        alpha = v / (v - iou + 1 + EPS)\n    # Compute CIoU\n    ciou = diou - alpha * v\n    return ciou.to(dtype)", "n_imports_parsed": 9, "n_files_resolved": 3, "n_chars_extracted": 2502}, "tests/test_tools/test_dataset_preparation.py::25": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/dataset_preparation.py"], "used_names": ["Config", "Path", "os", "prepare_dataset", "shutil"], "enclosing_function": "test_prepare_dataset", "extracted_code": "# Source: yolo/config/config.py\nclass Config:\n    task: Union[TrainConfig, InferenceConfig, ValidationConfig]\n    dataset: DatasetConfig\n    model: ModelConfig\n    name: str\n\n    accelerator: Optional[str]\n    device: Union[str, int, List[int]]\n    cpu_num: int\n\n    image_size: List[int]\n\n    out_path: str\n    exist_ok: bool\n\n    lucky_number: 10\n    use_wandb: bool\n    use_tensorboard: bool\n\n    weight: Optional[str]\n\n\n# Source: yolo/tools/dataset_preparation.py\ndef prepare_dataset(dataset_cfg: DatasetConfig, task: str):\n    \"\"\"\n    Prepares dataset by downloading and unzipping if necessary.\n    \"\"\"\n    # TODO: do EDA of dataset\n    data_dir = Path(dataset_cfg.path)\n    for data_type, settings in dataset_cfg.auto_download.items():\n        base_url = settings[\"base_url\"]\n        for dataset_type, dataset_args in settings.items():\n            if dataset_type != \"annotations\" and dataset_cfg.get(task, task) != dataset_type:\n                continue\n            file_name = f\"{dataset_args.get('file_name', dataset_type)}.zip\"\n            url = f\"{base_url}{file_name}\"\n            local_zip_path = data_dir / file_name\n            extract_to = data_dir / data_type if data_type != \"annotations\" else data_dir\n            final_place = extract_to / dataset_type\n\n            final_place.mkdir(parents=True, exist_ok=True)\n            if check_files(final_place, dataset_args.get(\"file_num\")):\n                logger.info(f\":white_check_mark: Dataset {dataset_type: <12} already verified.\")\n                continue\n\n            if not local_zip_path.exists():\n                download_file(url, local_zip_path)\n            unzip_file(local_zip_path, extract_to)\n\n            if not check_files(final_place, dataset_args.get(\"file_num\")):\n                logger.error(f\"Error verifying the {dataset_type} dataset after extraction.\")", "n_imports_parsed": 6, "n_files_resolved": 2, "n_chars_extracted": 1842}, "tests/test_model/test_module.py::29": {"resolved_imports": ["yolo/model/module.py"], "used_names": ["Pool", "torch"], "enclosing_function": "test_pool_max", "extracted_code": "# Source: yolo/model/module.py\nclass Pool(nn.Module):\n    \"\"\"A generic pooling block supporting 'max' and 'avg' pooling methods.\"\"\"\n\n    def __init__(self, method: str = \"max\", kernel_size: _size_2_t = 2, **kwargs):\n        super().__init__()\n        kwargs.setdefault(\"padding\", auto_pad(kernel_size, **kwargs))\n        pool_classes = {\"max\": nn.MaxPool2d, \"avg\": nn.AvgPool2d}\n        self.pool = pool_classes[method.lower()](kernel_size=kernel_size, **kwargs)\n\n    def forward(self, x: Tensor) -> Tensor:\n        return self.pool(x)", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 535}, "tests/test_tools/test_data_loader.py::45": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["DataLoader", "Path"], "enclosing_function": "test_validation_data_loader_correctness", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_tools/test_solver.py::78": {"resolved_imports": ["yolo/config/config.py", "yolo/model/yolo.py", "yolo/tools/data_loader.py", "yolo/tools/solver.py", "yolo/utils/bounding_box_utils.py"], "used_names": ["TrainModel", "Trainer", "YOLO"], "enclosing_function": "test_model_trainer_initialization", "extracted_code": "# Source: yolo/model/yolo.py\nclass YOLO(nn.Module):\n    \"\"\"\n    A preliminary YOLO (You Only Look Once) model class still under development.\n\n    Parameters:\n        model_cfg: Configuration for the YOLO model. Expected to define the layers,\n                   parameters, and any other relevant configuration details.\n    \"\"\"\n\n    def __init__(self, model_cfg: ModelConfig, class_num: int = 80):\n        super(YOLO, self).__init__()\n        self.num_classes = class_num\n        self.layer_map = get_layer_map()  # Get the map Dict[str: Module]\n        self.model: List[YOLOLayer] = nn.ModuleList()\n        self.reg_max = getattr(model_cfg.anchor, \"reg_max\", 16)\n        self.build_model(model_cfg.model)\n\n    def build_model(self, model_arch: Dict[str, List[Dict[str, Dict[str, Dict]]]]):\n        self.layer_index = {}\n        output_dim, layer_idx = [3], 1\n        logger.info(f\":tractor: Building YOLO\")\n        for arch_name in model_arch:\n            if model_arch[arch_name]:\n                logger.info(f\"  :building_construction:  Building {arch_name}\")\n            for layer_idx, layer_spec in enumerate(model_arch[arch_name], start=layer_idx):\n                layer_type, layer_info = next(iter(layer_spec.items()))\n                layer_args = layer_info.get(\"args\", {})\n\n                # Get input source\n                source = self.get_source_idx(layer_info.get(\"source\", -1), layer_idx)\n\n                # Find in channels\n                if any(module in layer_type for module in [\"Conv\", \"ELAN\", \"ADown\", \"AConv\", \"CBLinear\"]):\n                    layer_args[\"in_channels\"] = output_dim[source]\n                if any(module in layer_type for module in [\"Detection\", \"Segmentation\", \"Classification\"]):\n                    if isinstance(source, list):\n                        layer_args[\"in_channels\"] = [output_dim[idx] for idx in source]\n                    else:\n                        layer_args[\"in_channel\"] = output_dim[source]\n                    layer_args[\"num_classes\"] = self.num_classes\n                    layer_args[\"reg_max\"] = self.reg_max\n\n                # create layers\n                layer = self.create_layer(layer_type, source, layer_info, **layer_args)\n                self.model.append(layer)\n\n                if layer.tags:\n                    if layer.tags in self.layer_index:\n                        raise ValueError(f\"Duplicate tag '{layer_info['tags']}' found.\")\n                    self.layer_index[layer.tags] = layer_idx\n\n                out_channels = self.get_out_channels(layer_type, layer_args, output_dim, source)\n                output_dim.append(out_channels)\n                setattr(layer, \"out_c\", out_channels)\n            layer_idx += 1\n\n    def forward(self, x, external: Optional[Dict] = None, shortcut: Optional[str] = None):\n        y = {0: x, **(external or {})}\n        output = dict()\n        for index, layer in enumerate(self.model, start=1):\n            if isinstance(layer.source, list):\n                model_input = [y[idx] for idx in layer.source]\n            else:\n                model_input = y[layer.source]\n\n            external_input = {source_name: y[source_name] for source_name in layer.external}\n\n            x = layer(model_input, **external_input)\n            y[-1] = x\n            if layer.usable:\n                y[index] = x\n            if layer.output:\n                output[layer.tags] = x\n                if layer.tags == shortcut:\n                    return output\n        return output\n\n    def get_out_channels(self, layer_type: str, layer_args: dict, output_dim: list, source: Union[int, list]):\n        if hasattr(layer_args, \"out_channels\"):\n            return layer_args[\"out_channels\"]\n        if layer_type == \"CBFuse\":\n            return output_dim[source[-1]]\n        if isinstance(source, int):\n            return output_dim[source]\n        if isinstance(source, list):\n            return sum(output_dim[idx] for idx in source)\n\n    def get_source_idx(self, source: Union[ListConfig, str, int], layer_idx: int):\n        if isinstance(source, ListConfig):\n            return [self.get_source_idx(index, layer_idx) for index in source]\n        if isinstance(source, str):\n            source = self.layer_index[source]\n        if source < -1:\n            source += layer_idx\n        if source > 0:  # Using Previous Layer's Output\n            self.model[source - 1].usable = True\n        return source\n\n    def create_layer(self, layer_type: str, source: Union[int, list], layer_info: Dict, **kwargs) -> YOLOLayer:\n        if layer_type in self.layer_map:\n            layer = self.layer_map[layer_type](**kwargs)\n            setattr(layer, \"layer_type\", layer_type)\n            setattr(layer, \"source\", source)\n            setattr(layer, \"in_c\", kwargs.get(\"in_channels\", None))\n            setattr(layer, \"output\", layer_info.get(\"output\", False))\n            setattr(layer, \"tags\", layer_info.get(\"tags\", None))\n            setattr(layer, \"external\", layer_info.get(\"external\", []))\n            setattr(layer, \"usable\", 0)\n            return layer\n        else:\n            raise ValueError(f\"Unsupported layer type: {layer_type}\")\n\n    def save_load_weights(self, weights: Union[Path, OrderedDict]):\n        \"\"\"\n        Update the model's weights with the provided weights.\n\n        args:\n            weights: A OrderedDict containing the new weights.\n        \"\"\"\n        if isinstance(weights, Path):\n            weights = torch.load(weights, map_location=torch.device(\"cpu\"), weights_only=False)\n        if \"state_dict\" in weights:\n            weights = {name.removeprefix(\"model.model.\"): key for name, key in weights[\"state_dict\"].items()}\n        model_state_dict = self.model.state_dict()\n\n        # TODO1: autoload old version weight\n        # TODO2: weight transform if num_class difference\n\n        error_dict = {\"Mismatch\": set(), \"Not Found\": set()}\n        for model_key, model_weight in model_state_dict.items():\n            if model_key not in weights:\n                error_dict[\"Not Found\"].add(tuple(model_key.split(\".\")[:-2]))\n                continue\n            if model_weight.shape != weights[model_key].shape:\n                error_dict[\"Mismatch\"].add(tuple(model_key.split(\".\")[:-2]))\n                continue\n            model_state_dict[model_key] = weights[model_key]\n\n        for error_name, error_set in error_dict.items():\n            error_dict = dict()\n            for layer_idx, *layer_name in error_set:\n                if layer_idx not in error_dict:\n                    error_dict[layer_idx] = [\".\".join(layer_name)]\n                else:\n                    error_dict[layer_idx].append(\".\".join(layer_name))\n            for layer_idx, layer_name in error_dict.items():\n                layer_name.sort()\n                logger.warning(f\":warning: Weight {error_name} for Layer {layer_idx}: {', '.join(layer_name)}\")\n\n        self.model.load_state_dict(model_state_dict)\n\n\n# Source: yolo/tools/solver.py\nclass TrainModel(ValidateModel):\n    def __init__(self, cfg: Config):\n        super().__init__(cfg)\n        self.cfg = cfg\n        self.train_loader = create_dataloader(self.cfg.task.data, self.cfg.dataset, self.cfg.task.task)\n\n    def setup(self, stage):\n        super().setup(stage)\n        self.loss_fn = create_loss_function(self.cfg, self.vec2box)\n\n    def train_dataloader(self):\n        return self.train_loader\n\n    def on_train_epoch_start(self):\n        self.trainer.optimizers[0].next_epoch(\n            ceil(len(self.train_loader) / self.trainer.world_size), self.current_epoch\n        )\n        self.vec2box.update(self.cfg.image_size)\n\n    def training_step(self, batch, batch_idx):\n        lr_dict = self.trainer.optimizers[0].next_batch()\n        batch_size, images, targets, *_ = batch\n        predicts = self(images)\n        aux_predicts = self.vec2box(predicts[\"AUX\"])\n        main_predicts = self.vec2box(predicts[\"Main\"])\n        loss, loss_item = self.loss_fn(aux_predicts, main_predicts, targets)\n        self.log_dict(\n            loss_item,\n            prog_bar=True,\n            on_epoch=True,\n            batch_size=batch_size,\n            rank_zero_only=True,\n        )\n        self.log_dict(lr_dict, prog_bar=False, logger=True, on_epoch=False, rank_zero_only=True)\n        return loss * batch_size\n\n    def configure_optimizers(self):\n        optimizer = create_optimizer(self.model, self.cfg.task.optimizer)\n        scheduler = create_scheduler(optimizer, self.cfg.task.scheduler)\n        return [optimizer], [scheduler]", "n_imports_parsed": 11, "n_files_resolved": 5, "n_chars_extracted": 8503}, "tests/test_utils/test_bounding_box_utils.py::123": {"resolved_imports": ["yolo/__init__.py", "yolo/config/config.py", "yolo/utils/bounding_box_utils.py"], "used_names": ["Config", "Vec2Box", "compose", "create_model", "initialize", "torch"], "enclosing_function": "test_vec2box_autoanchor", "extracted_code": "# Source: yolo/__init__.py\nfrom yolo.config.config import Config, NMSConfig\nfrom yolo.model.yolo import create_model\nfrom yolo.tools.data_loader import AugmentationComposer, create_dataloader\nfrom yolo.tools.drawer import draw_bboxes\nfrom yolo.tools.solver import TrainModel\nfrom yolo.utils.bounding_box_utils import Anc2Box, Vec2Box, bbox_nms, create_converter\nfrom yolo.utils.deploy_utils import FastModelLoader\nfrom yolo.utils.logging_utils import (\n    ImageLogger,\n    YOLORichModelSummary,\n\nfrom yolo.config.config import Config, NMSConfig\nfrom yolo.model.yolo import create_model\nfrom yolo.tools.data_loader import AugmentationComposer, create_dataloader\nfrom yolo.tools.drawer import draw_bboxes\nfrom yolo.tools.solver import TrainModel\nfrom yolo.utils.bounding_box_utils import Anc2Box, Vec2Box, bbox_nms, create_converter\nfrom yolo.utils.deploy_utils import FastModelLoader\nfrom yolo.utils.logging_utils import (\n    ImageLogger,\n    YOLORichModelSummary,\n    YOLORichProgressBar,\n\n\nall = [\n    \"create_model\",\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n\nall = [\n    \"create_model\",\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n    \"create_converter\",\n\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n    \"create_converter\",\n    \"AugmentationComposer\",\n    \"ImageLogger\",\n\n\n# Source: yolo/utils/bounding_box_utils.py\nclass Vec2Box:\n    def __init__(self, model: YOLO, anchor_cfg: AnchorConfig, image_size, device):\n        self.device = device\n\n        if hasattr(anchor_cfg, \"strides\"):\n            logger.info(f\":japanese_not_free_of_charge_button: Found stride of model {anchor_cfg.strides}\")\n            self.strides = anchor_cfg.strides\n        else:\n            logger.info(\":teddy_bear: Found no stride of model, performed a dummy test for auto-anchor size\")\n            self.strides = self.create_auto_anchor(model, image_size)\n\n        anchor_grid, scaler = generate_anchors(image_size, self.strides)\n        self.image_size = image_size\n        self.anchor_grid, self.scaler = anchor_grid.to(device), scaler.to(device)\n\n    def create_auto_anchor(self, model: YOLO, image_size):\n        W, H = image_size\n        # TODO: need accelerate dummy test\n        dummy_input = torch.zeros(1, 3, H, W)\n        dummy_output = model(dummy_input)\n        strides = []\n        for predict_head in dummy_output[\"Main\"]:\n            _, _, *anchor_num = predict_head[2].shape\n            strides.append(W // anchor_num[1])\n        return strides\n\n    def update(self, image_size):\n        \"\"\"\n        image_size: W, H\n        \"\"\"\n        if self.image_size == image_size:\n            return\n        anchor_grid, scaler = generate_anchors(image_size, self.strides)\n        self.image_size = image_size\n        self.anchor_grid, self.scaler = anchor_grid.to(self.device), scaler.to(self.device)\n\n    def __call__(self, predicts):\n        preds_cls, preds_anc, preds_box = [], [], []\n        for layer_output in predicts:\n            pred_cls, pred_anc, pred_box = layer_output\n            preds_cls.append(rearrange(pred_cls, \"B C h w -> B (h w) C\"))\n            preds_anc.append(rearrange(pred_anc, \"B A R h w -> B (h w) R A\"))\n            preds_box.append(rearrange(pred_box, \"B X h w -> B (h w) X\"))\n        preds_cls = torch.concat(preds_cls, dim=1)\n        preds_anc = torch.concat(preds_anc, dim=1)\n        preds_box = torch.concat(preds_box, dim=1)\n\n        pred_LTRB = preds_box * self.scaler.view(1, -1, 1)\n        lt, rb = pred_LTRB.chunk(2, dim=-1)\n        preds_box = torch.cat([self.anchor_grid - lt, self.anchor_grid + rb], dim=-1)\n        return preds_cls, preds_anc, preds_box", "n_imports_parsed": 9, "n_files_resolved": 3, "n_chars_extracted": 4002}, "tests/test_utils/test_bounding_box_utils.py::140": {"resolved_imports": ["yolo/__init__.py", "yolo/config/config.py", "yolo/utils/bounding_box_utils.py"], "used_names": ["Anc2Box", "AnchorConfig", "Config", "create_model", "torch"], "enclosing_function": "test_anc2box_autoanchor", "extracted_code": "# Source: yolo/__init__.py\nfrom yolo.config.config import Config, NMSConfig\nfrom yolo.model.yolo import create_model\nfrom yolo.tools.data_loader import AugmentationComposer, create_dataloader\nfrom yolo.tools.drawer import draw_bboxes\nfrom yolo.tools.solver import TrainModel\nfrom yolo.utils.bounding_box_utils import Anc2Box, Vec2Box, bbox_nms, create_converter\nfrom yolo.utils.deploy_utils import FastModelLoader\nfrom yolo.utils.logging_utils import (\n    ImageLogger,\n    YOLORichModelSummary,\n\nfrom yolo.config.config import Config, NMSConfig\nfrom yolo.model.yolo import create_model\nfrom yolo.tools.data_loader import AugmentationComposer, create_dataloader\nfrom yolo.tools.drawer import draw_bboxes\nfrom yolo.tools.solver import TrainModel\nfrom yolo.utils.bounding_box_utils import Anc2Box, Vec2Box, bbox_nms, create_converter\nfrom yolo.utils.deploy_utils import FastModelLoader\nfrom yolo.utils.logging_utils import (\n    ImageLogger,\n    YOLORichModelSummary,\n    YOLORichProgressBar,\n\n\nall = [\n    \"create_model\",\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n\nall = [\n    \"create_model\",\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n    \"create_converter\",\n\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n    \"create_converter\",\n    \"AugmentationComposer\",\n    \"ImageLogger\",\n\n\n# Source: yolo/config/config.py\nclass AnchorConfig:\n    strides: List[int]\n    reg_max: Optional[int]\n    anchor_num: Optional[int]\n    anchor: List[List[int]]\n\n\n# Source: yolo/utils/bounding_box_utils.py\nclass Anc2Box:\n    def __init__(self, model: YOLO, anchor_cfg: AnchorConfig, image_size, device):\n        self.device = device\n\n        if hasattr(anchor_cfg, \"strides\"):\n            logger.info(f\":japanese_not_free_of_charge_button: Found stride of model {anchor_cfg.strides}\")\n            self.strides = anchor_cfg.strides\n        else:\n            logger.info(\":teddy_bear: Found no stride of model, performed a dummy test for auto-anchor size\")\n            self.strides = self.create_auto_anchor(model, image_size)\n\n        self.head_num = len(anchor_cfg.anchor)\n        self.anchor_grids = self.generate_anchors(image_size)\n        self.anchor_scale = tensor(anchor_cfg.anchor, device=device).view(self.head_num, 1, -1, 1, 1, 2)\n        self.anchor_num = self.anchor_scale.size(2)\n        self.class_num = model.num_classes\n\n    def create_auto_anchor(self, model: YOLO, image_size):\n        W, H = image_size\n        dummy_input = torch.zeros(1, 3, H, W).to(self.device)\n        dummy_output = model(dummy_input)\n        strides = []\n        for predict_head in dummy_output[\"Main\"]:\n            _, _, *anchor_num = predict_head.shape\n            strides.append(W // anchor_num[1])\n        return strides\n\n    def generate_anchors(self, image_size: List[int]):\n        anchor_grids = []\n        for stride in self.strides:\n            W, H = image_size[0] // stride, image_size[1] // stride\n            anchor_h, anchor_w = torch.meshgrid([torch.arange(H), torch.arange(W)], indexing=\"ij\")\n            anchor_grid = torch.stack((anchor_w, anchor_h), 2).view((1, 1, H, W, 2)).float().to(self.device)\n            anchor_grids.append(anchor_grid)\n        return anchor_grids\n\n    def update(self, image_size):\n        self.anchor_grids = self.generate_anchors(image_size)\n\n    def __call__(self, predicts: List[Tensor]):\n        preds_box, preds_cls, preds_cnf = [], [], []\n        for layer_idx, predict in enumerate(predicts):\n            predict = rearrange(predict, \"B (L C) h w -> B L h w C\", L=self.anchor_num)\n            pred_box, pred_cnf, pred_cls = predict.split((4, 1, self.class_num), dim=-1)\n            pred_box = pred_box.sigmoid()\n            pred_box[..., 0:2] = (pred_box[..., 0:2] * 2.0 - 0.5 + self.anchor_grids[layer_idx]) * self.strides[\n                layer_idx\n            ]\n            pred_box[..., 2:4] = (pred_box[..., 2:4] * 2) ** 2 * self.anchor_scale[layer_idx]\n            preds_box.append(rearrange(pred_box, \"B L h w A -> B (L h w) A\"))\n            preds_cls.append(rearrange(pred_cls, \"B L h w C -> B (L h w) C\"))\n            preds_cnf.append(rearrange(pred_cnf, \"B L h w C -> B (L h w) C\"))\n\n        preds_box = torch.concat(preds_box, dim=1)\n        preds_cls = torch.concat(preds_cls, dim=1)\n        preds_cnf = torch.concat(preds_cnf, dim=1)\n\n        preds_box = transform_bbox(preds_box, \"xycwh -> xyxy\")\n        return preds_cls, None, preds_box, preds_cnf.sigmoid()", "n_imports_parsed": 9, "n_files_resolved": 3, "n_chars_extracted": 4808}, "tests/test_utils/test_module_utils.py::41": {"resolved_imports": ["yolo/utils/module_utils.py"], "used_names": ["create_activation_function", "pytest"], "enclosing_function": "test_get_activation_invalid", "extracted_code": "# Source: yolo/utils/module_utils.py\ndef create_activation_function(activation: str) -> nn.Module:\n    \"\"\"\n    Retrieves an activation function from the PyTorch nn module based on its name, case-insensitively.\n    \"\"\"\n    if not activation or activation.lower() in [\"false\", \"none\"]:\n        return nn.Identity()\n\n    activation_map = {\n        name.lower(): obj\n        for name, obj in nn.modules.activation.__dict__.items()\n        if isinstance(obj, type) and issubclass(obj, nn.Module)\n    }\n    if activation.lower() in activation_map:\n        return activation_map[activation.lower()](inplace=True)\n    else:\n        raise ValueError(f\"Activation function '{activation}' is not found in torch.nn\")", "n_imports_parsed": 6, "n_files_resolved": 1, "n_chars_extracted": 704}, "tests/test_utils/test_module_utils.py::28": {"resolved_imports": ["yolo/utils/module_utils.py"], "used_names": ["auto_pad", "pytest"], "enclosing_function": "test_auto_pad", "extracted_code": "# Source: yolo/utils/module_utils.py\ndef auto_pad(kernel_size: _size_2_t, dilation: _size_2_t = 1, **kwargs) -> Tuple[int, int]:\n    \"\"\"\n    Auto Padding for the convolution blocks\n    \"\"\"\n    if isinstance(kernel_size, int):\n        kernel_size = (kernel_size, kernel_size)\n    if isinstance(dilation, int):\n        dilation = (dilation, dilation)\n\n    pad_h = ((kernel_size[0] - 1) * dilation[0]) // 2\n    pad_w = ((kernel_size[1] - 1) * dilation[1]) // 2\n    return (pad_h, pad_w)", "n_imports_parsed": 6, "n_files_resolved": 1, "n_chars_extracted": 483}, "tests/test_model/test_module.py::50": {"resolved_imports": ["yolo/model/module.py"], "used_names": ["CBLinear", "torch"], "enclosing_function": "test_cblinear", "extracted_code": "# Source: yolo/model/module.py\nclass CBLinear(nn.Module):\n    \"\"\"Convolutional block that outputs multiple feature maps split along the channel dimension.\"\"\"\n\n    def __init__(self, in_channels: int, out_channels: List[int], kernel_size: int = 1, **kwargs):\n        super(CBLinear, self).__init__()\n        kwargs.setdefault(\"padding\", auto_pad(kernel_size, **kwargs))\n        self.conv = nn.Conv2d(in_channels, sum(out_channels), kernel_size, **kwargs)\n        self.out_channels = list(out_channels)\n\n    def forward(self, x: Tensor) -> Tuple[Tensor]:\n        x = self.conv(x)\n        return x.split(self.out_channels, dim=1)", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 626}, "tests/test_utils/test_bounding_box_utils.py::101": {"resolved_imports": ["yolo/__init__.py", "yolo/config/config.py", "yolo/utils/bounding_box_utils.py"], "used_names": ["pytest", "transform_bbox"], "enclosing_function": "test_transform_bbox_invalid_format", "extracted_code": "# Source: yolo/utils/bounding_box_utils.py\ndef transform_bbox(bbox: Tensor, indicator=\"xywh -> xyxy\"):\n    data_type = bbox.dtype\n    in_type, out_type = indicator.replace(\" \", \"\").split(\"->\")\n\n    if in_type not in [\"xyxy\", \"xywh\", \"xycwh\"] or out_type not in [\"xyxy\", \"xywh\", \"xycwh\"]:\n        raise ValueError(\"Invalid input or output format\")\n\n    if in_type == \"xywh\":\n        x_min = bbox[..., 0]\n        y_min = bbox[..., 1]\n        x_max = bbox[..., 0] + bbox[..., 2]\n        y_max = bbox[..., 1] + bbox[..., 3]\n    elif in_type == \"xyxy\":\n        x_min = bbox[..., 0]\n        y_min = bbox[..., 1]\n        x_max = bbox[..., 2]\n        y_max = bbox[..., 3]\n    elif in_type == \"xycwh\":\n        x_min = bbox[..., 0] - bbox[..., 2] / 2\n        y_min = bbox[..., 1] - bbox[..., 3] / 2\n        x_max = bbox[..., 0] + bbox[..., 2] / 2\n        y_max = bbox[..., 1] + bbox[..., 3] / 2\n\n    if out_type == \"xywh\":\n        bbox = torch.stack([x_min, y_min, x_max - x_min, y_max - y_min], dim=-1)\n    elif out_type == \"xyxy\":\n        bbox = torch.stack([x_min, y_min, x_max, y_max], dim=-1)\n    elif out_type == \"xycwh\":\n        bbox = torch.stack([(x_min + x_max) / 2, (y_min + y_max) / 2, x_max - x_min, y_max - y_min], dim=-1)\n\n    return bbox.to(dtype=data_type)", "n_imports_parsed": 9, "n_files_resolved": 3, "n_chars_extracted": 1263}, "tests/test_utils/test_bounding_box_utils.py::126": {"resolved_imports": ["yolo/__init__.py", "yolo/config/config.py", "yolo/utils/bounding_box_utils.py"], "used_names": ["Config", "Vec2Box", "compose", "create_model", "initialize", "torch"], "enclosing_function": "test_vec2box_autoanchor", "extracted_code": "# Source: yolo/__init__.py\nfrom yolo.config.config import Config, NMSConfig\nfrom yolo.model.yolo import create_model\nfrom yolo.tools.data_loader import AugmentationComposer, create_dataloader\nfrom yolo.tools.drawer import draw_bboxes\nfrom yolo.tools.solver import TrainModel\nfrom yolo.utils.bounding_box_utils import Anc2Box, Vec2Box, bbox_nms, create_converter\nfrom yolo.utils.deploy_utils import FastModelLoader\nfrom yolo.utils.logging_utils import (\n    ImageLogger,\n    YOLORichModelSummary,\n\nfrom yolo.config.config import Config, NMSConfig\nfrom yolo.model.yolo import create_model\nfrom yolo.tools.data_loader import AugmentationComposer, create_dataloader\nfrom yolo.tools.drawer import draw_bboxes\nfrom yolo.tools.solver import TrainModel\nfrom yolo.utils.bounding_box_utils import Anc2Box, Vec2Box, bbox_nms, create_converter\nfrom yolo.utils.deploy_utils import FastModelLoader\nfrom yolo.utils.logging_utils import (\n    ImageLogger,\n    YOLORichModelSummary,\n    YOLORichProgressBar,\n\n\nall = [\n    \"create_model\",\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n\nall = [\n    \"create_model\",\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n    \"create_converter\",\n\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n    \"create_converter\",\n    \"AugmentationComposer\",\n    \"ImageLogger\",\n\n\n# Source: yolo/utils/bounding_box_utils.py\nclass Vec2Box:\n    def __init__(self, model: YOLO, anchor_cfg: AnchorConfig, image_size, device):\n        self.device = device\n\n        if hasattr(anchor_cfg, \"strides\"):\n            logger.info(f\":japanese_not_free_of_charge_button: Found stride of model {anchor_cfg.strides}\")\n            self.strides = anchor_cfg.strides\n        else:\n            logger.info(\":teddy_bear: Found no stride of model, performed a dummy test for auto-anchor size\")\n            self.strides = self.create_auto_anchor(model, image_size)\n\n        anchor_grid, scaler = generate_anchors(image_size, self.strides)\n        self.image_size = image_size\n        self.anchor_grid, self.scaler = anchor_grid.to(device), scaler.to(device)\n\n    def create_auto_anchor(self, model: YOLO, image_size):\n        W, H = image_size\n        # TODO: need accelerate dummy test\n        dummy_input = torch.zeros(1, 3, H, W)\n        dummy_output = model(dummy_input)\n        strides = []\n        for predict_head in dummy_output[\"Main\"]:\n            _, _, *anchor_num = predict_head[2].shape\n            strides.append(W // anchor_num[1])\n        return strides\n\n    def update(self, image_size):\n        \"\"\"\n        image_size: W, H\n        \"\"\"\n        if self.image_size == image_size:\n            return\n        anchor_grid, scaler = generate_anchors(image_size, self.strides)\n        self.image_size = image_size\n        self.anchor_grid, self.scaler = anchor_grid.to(self.device), scaler.to(self.device)\n\n    def __call__(self, predicts):\n        preds_cls, preds_anc, preds_box = [], [], []\n        for layer_output in predicts:\n            pred_cls, pred_anc, pred_box = layer_output\n            preds_cls.append(rearrange(pred_cls, \"B C h w -> B (h w) C\"))\n            preds_anc.append(rearrange(pred_anc, \"B A R h w -> B (h w) R A\"))\n            preds_box.append(rearrange(pred_box, \"B X h w -> B (h w) X\"))\n        preds_cls = torch.concat(preds_cls, dim=1)\n        preds_anc = torch.concat(preds_anc, dim=1)\n        preds_box = torch.concat(preds_box, dim=1)\n\n        pred_LTRB = preds_box * self.scaler.view(1, -1, 1)\n        lt, rb = pred_LTRB.chunk(2, dim=-1)\n        preds_box = torch.cat([self.anchor_grid - lt, self.anchor_grid + rb], dim=-1)\n        return preds_cls, preds_anc, preds_box", "n_imports_parsed": 9, "n_files_resolved": 3, "n_chars_extracted": 4002}, "tests/test_tools/test_data_loader.py::62": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["StreamDataLoader"], "enclosing_function": "test_file_stream_data_loader_frame", "extracted_code": "# Source: yolo/tools/data_loader.py\nclass StreamDataLoader:\n    def __init__(self, data_cfg: DataConfig):\n        self.source = data_cfg.source\n        self.running = True\n        self.is_stream = isinstance(self.source, int) or str(self.source).lower().startswith(\"rtmp://\")\n\n        self.transform = AugmentationComposer([], data_cfg.image_size)\n        self.stop_event = Event()\n\n        if self.is_stream:\n            import cv2\n\n            self.cap = cv2.VideoCapture(self.source)\n        else:\n            self.source = Path(self.source)\n            self.queue = Queue()\n            self.thread = Thread(target=self.load_source)\n            self.thread.start()\n\n    def load_source(self):\n        if self.source.is_dir():  # image folder\n            self.load_image_folder(self.source)\n        elif any(self.source.suffix.lower().endswith(ext) for ext in [\".mp4\", \".avi\", \".mkv\"]):  # Video file\n            self.load_video_file(self.source)\n        else:  # Single image\n            self.process_image(self.source)\n\n    def load_image_folder(self, folder):\n        folder_path = Path(folder)\n        for file_path in folder_path.rglob(\"*\"):\n            if self.stop_event.is_set():\n                break\n            if file_path.suffix.lower() in [\".jpg\", \".jpeg\", \".png\", \".bmp\"]:\n                self.process_image(file_path)\n\n    def process_image(self, image_path):\n        image = Image.open(image_path).convert(\"RGB\")\n        if image is None:\n            raise ValueError(f\"Error loading image: {image_path}\")\n        self.process_frame(image)\n\n    def load_video_file(self, video_path):\n        import cv2\n\n        cap = cv2.VideoCapture(str(video_path))\n        while self.running:\n            ret, frame = cap.read()\n            if not ret:\n                break\n            self.process_frame(frame)\n        cap.release()\n\n    def process_frame(self, frame):\n        if isinstance(frame, np.ndarray):\n            # TODO: we don't need cv2\n            import cv2\n\n            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n            frame = Image.fromarray(frame)\n        origin_frame = frame\n        frame, _, rev_tensor = self.transform(frame, torch.zeros(0, 5))\n        frame = frame[None]\n        rev_tensor = rev_tensor[None]\n        if not self.is_stream:\n            self.queue.put((frame, rev_tensor, origin_frame))\n        else:\n            self.current_frame = (frame, rev_tensor, origin_frame)\n\n    def __iter__(self) -> Generator[Tensor, None, None]:\n        return self\n\n    def __next__(self) -> Tensor:\n        if self.is_stream:\n            ret, frame = self.cap.read()\n            if not ret:\n                self.stop()\n                raise StopIteration\n            self.process_frame(frame)\n            return self.current_frame\n        else:\n            try:\n                frame = self.queue.get(timeout=1)\n                return frame\n            except Empty:\n                raise StopIteration\n\n    def stop(self):\n        self.running = False\n        if self.is_stream:\n            self.cap.release()\n        else:\n            self.thread.join(timeout=1)\n\n    def __len__(self):\n        return self.queue.qsize() if not self.is_stream else 0", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 3190}, "tests/test_utils/test_bounding_box_utils.py::113": {"resolved_imports": ["yolo/__init__.py", "yolo/config/config.py", "yolo/utils/bounding_box_utils.py"], "used_names": ["generate_anchors"], "enclosing_function": "test_generate_anchors", "extracted_code": "# Source: yolo/utils/bounding_box_utils.py\ndef generate_anchors(image_size: List[int], strides: List[int]):\n    \"\"\"\n    Find the anchor maps for each w, h.\n\n    Args:\n        image_size List: the image size of augmented image size\n        strides List[8, 16, 32, ...]: the stride size for each predicted layer\n\n    Returns:\n        all_anchors [HW x 2]:\n        all_scalers [HW]: The index of the best targets for each anchors\n    \"\"\"\n    W, H = image_size\n    anchors = []\n    scaler = []\n    for stride in strides:\n        anchor_num = W // stride * H // stride\n        scaler.append(torch.full((anchor_num,), stride))\n        shift = stride // 2\n        h = torch.arange(0, H, stride) + shift\n        w = torch.arange(0, W, stride) + shift\n        if torch.__version__ >= \"2.3.0\":\n            anchor_h, anchor_w = torch.meshgrid(h, w, indexing=\"ij\")\n        else:\n            anchor_h, anchor_w = torch.meshgrid(h, w)\n        anchor = torch.stack([anchor_w.flatten(), anchor_h.flatten()], dim=-1)\n        anchors.append(anchor)\n    all_anchors = torch.cat(anchors, dim=0)\n    all_scalers = torch.cat(scaler, dim=0)\n    return all_anchors, all_scalers\n\nclass Anc2Box:\n    def __init__(self, model: YOLO, anchor_cfg: AnchorConfig, image_size, device):\n        self.device = device\n\n        if hasattr(anchor_cfg, \"strides\"):\n            logger.info(f\":japanese_not_free_of_charge_button: Found stride of model {anchor_cfg.strides}\")\n            self.strides = anchor_cfg.strides\n        else:\n            logger.info(\":teddy_bear: Found no stride of model, performed a dummy test for auto-anchor size\")\n            self.strides = self.create_auto_anchor(model, image_size)\n\n        self.head_num = len(anchor_cfg.anchor)\n        self.anchor_grids = self.generate_anchors(image_size)\n        self.anchor_scale = tensor(anchor_cfg.anchor, device=device).view(self.head_num, 1, -1, 1, 1, 2)\n        self.anchor_num = self.anchor_scale.size(2)\n        self.class_num = model.num_classes\n\n    def create_auto_anchor(self, model: YOLO, image_size):\n        W, H = image_size\n        dummy_input = torch.zeros(1, 3, H, W).to(self.device)\n        dummy_output = model(dummy_input)\n        strides = []\n        for predict_head in dummy_output[\"Main\"]:\n            _, _, *anchor_num = predict_head.shape\n            strides.append(W // anchor_num[1])\n        return strides\n\n    def generate_anchors(self, image_size: List[int]):\n        anchor_grids = []\n        for stride in self.strides:\n            W, H = image_size[0] // stride, image_size[1] // stride\n            anchor_h, anchor_w = torch.meshgrid([torch.arange(H), torch.arange(W)], indexing=\"ij\")\n            anchor_grid = torch.stack((anchor_w, anchor_h), 2).view((1, 1, H, W, 2)).float().to(self.device)\n            anchor_grids.append(anchor_grid)\n        return anchor_grids\n\n    def update(self, image_size):\n        self.anchor_grids = self.generate_anchors(image_size)\n\n    def __call__(self, predicts: List[Tensor]):\n        preds_box, preds_cls, preds_cnf = [], [], []\n        for layer_idx, predict in enumerate(predicts):\n            predict = rearrange(predict, \"B (L C) h w -> B L h w C\", L=self.anchor_num)\n            pred_box, pred_cnf, pred_cls = predict.split((4, 1, self.class_num), dim=-1)\n            pred_box = pred_box.sigmoid()\n            pred_box[..., 0:2] = (pred_box[..., 0:2] * 2.0 - 0.5 + self.anchor_grids[layer_idx]) * self.strides[\n                layer_idx\n            ]\n            pred_box[..., 2:4] = (pred_box[..., 2:4] * 2) ** 2 * self.anchor_scale[layer_idx]\n            preds_box.append(rearrange(pred_box, \"B L h w A -> B (L h w) A\"))\n            preds_cls.append(rearrange(pred_cls, \"B L h w C -> B (L h w) C\"))\n            preds_cnf.append(rearrange(pred_cnf, \"B L h w C -> B (L h w) C\"))\n\n        preds_box = torch.concat(preds_box, dim=1)\n        preds_cls = torch.concat(preds_cls, dim=1)\n        preds_cnf = torch.concat(preds_cnf, dim=1)\n\n        preds_box = transform_bbox(preds_box, \"xycwh -> xyxy\")\n        return preds_cls, None, preds_box, preds_cnf.sigmoid()", "n_imports_parsed": 9, "n_files_resolved": 3, "n_chars_extracted": 4067}, "tests/test_tools/test_loss_functions.py::54": {"resolved_imports": ["yolo/config/config.py", "yolo/model/yolo.py", "yolo/tools/loss_functions.py", "yolo/utils/bounding_box_utils.py"], "used_names": [], "enclosing_function": "test_yolo_loss", "extracted_code": "", "n_imports_parsed": 10, "n_files_resolved": 4, "n_chars_extracted": 0}, "tests/test_tools/test_data_loader.py::46": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["DataLoader", "Path"], "enclosing_function": "test_validation_data_loader_correctness", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_tools/test_data_loader.py::64": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["StreamDataLoader"], "enclosing_function": "test_file_stream_data_loader_frame", "extracted_code": "# Source: yolo/tools/data_loader.py\nclass StreamDataLoader:\n    def __init__(self, data_cfg: DataConfig):\n        self.source = data_cfg.source\n        self.running = True\n        self.is_stream = isinstance(self.source, int) or str(self.source).lower().startswith(\"rtmp://\")\n\n        self.transform = AugmentationComposer([], data_cfg.image_size)\n        self.stop_event = Event()\n\n        if self.is_stream:\n            import cv2\n\n            self.cap = cv2.VideoCapture(self.source)\n        else:\n            self.source = Path(self.source)\n            self.queue = Queue()\n            self.thread = Thread(target=self.load_source)\n            self.thread.start()\n\n    def load_source(self):\n        if self.source.is_dir():  # image folder\n            self.load_image_folder(self.source)\n        elif any(self.source.suffix.lower().endswith(ext) for ext in [\".mp4\", \".avi\", \".mkv\"]):  # Video file\n            self.load_video_file(self.source)\n        else:  # Single image\n            self.process_image(self.source)\n\n    def load_image_folder(self, folder):\n        folder_path = Path(folder)\n        for file_path in folder_path.rglob(\"*\"):\n            if self.stop_event.is_set():\n                break\n            if file_path.suffix.lower() in [\".jpg\", \".jpeg\", \".png\", \".bmp\"]:\n                self.process_image(file_path)\n\n    def process_image(self, image_path):\n        image = Image.open(image_path).convert(\"RGB\")\n        if image is None:\n            raise ValueError(f\"Error loading image: {image_path}\")\n        self.process_frame(image)\n\n    def load_video_file(self, video_path):\n        import cv2\n\n        cap = cv2.VideoCapture(str(video_path))\n        while self.running:\n            ret, frame = cap.read()\n            if not ret:\n                break\n            self.process_frame(frame)\n        cap.release()\n\n    def process_frame(self, frame):\n        if isinstance(frame, np.ndarray):\n            # TODO: we don't need cv2\n            import cv2\n\n            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n            frame = Image.fromarray(frame)\n        origin_frame = frame\n        frame, _, rev_tensor = self.transform(frame, torch.zeros(0, 5))\n        frame = frame[None]\n        rev_tensor = rev_tensor[None]\n        if not self.is_stream:\n            self.queue.put((frame, rev_tensor, origin_frame))\n        else:\n            self.current_frame = (frame, rev_tensor, origin_frame)\n\n    def __iter__(self) -> Generator[Tensor, None, None]:\n        return self\n\n    def __next__(self) -> Tensor:\n        if self.is_stream:\n            ret, frame = self.cap.read()\n            if not ret:\n                self.stop()\n                raise StopIteration\n            self.process_frame(frame)\n            return self.current_frame\n        else:\n            try:\n                frame = self.queue.get(timeout=1)\n                return frame\n            except Empty:\n                raise StopIteration\n\n    def stop(self):\n        self.running = False\n        if self.is_stream:\n            self.cap.release()\n        else:\n            self.thread.join(timeout=1)\n\n    def __len__(self):\n        return self.queue.qsize() if not self.is_stream else 0", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 3190}, "tests/test_tools/test_data_augmentation.py::28": {"resolved_imports": ["yolo/tools/data_augmentation.py"], "used_names": ["HorizontalFlip", "Image", "torch"], "enclosing_function": "test_horizontal_flip", "extracted_code": "# Source: yolo/tools/data_augmentation.py\nclass HorizontalFlip:\n    \"\"\"Randomly horizontally flips the image along with the bounding boxes.\"\"\"\n\n    def __init__(self, prob=0.5):\n        self.prob = prob\n\n    def __call__(self, image, boxes):\n        if torch.rand(1) < self.prob:\n            image = TF.hflip(image)\n            boxes[:, [1, 3]] = 1 - boxes[:, [3, 1]]\n        return image, boxes", "n_imports_parsed": 6, "n_files_resolved": 1, "n_chars_extracted": 395}, "tests/test_model/test_yolo.py::46": {"resolved_imports": ["yolo/config/config.py", "yolo/model/yolo.py"], "used_names": ["Config", "OmegaConf", "YOLO", "compose", "initialize"], "enclosing_function": "test_build_model_v7", "extracted_code": "# Source: yolo/config/config.py\nclass Config:\n    task: Union[TrainConfig, InferenceConfig, ValidationConfig]\n    dataset: DatasetConfig\n    model: ModelConfig\n    name: str\n\n    accelerator: Optional[str]\n    device: Union[str, int, List[int]]\n    cpu_num: int\n\n    image_size: List[int]\n\n    out_path: str\n    exist_ok: bool\n\n    lucky_number: 10\n    use_wandb: bool\n    use_tensorboard: bool\n\n    weight: Optional[str]\n\n\n# Source: yolo/model/yolo.py\nclass YOLO(nn.Module):\n    \"\"\"\n    A preliminary YOLO (You Only Look Once) model class still under development.\n\n    Parameters:\n        model_cfg: Configuration for the YOLO model. Expected to define the layers,\n                   parameters, and any other relevant configuration details.\n    \"\"\"\n\n    def __init__(self, model_cfg: ModelConfig, class_num: int = 80):\n        super(YOLO, self).__init__()\n        self.num_classes = class_num\n        self.layer_map = get_layer_map()  # Get the map Dict[str: Module]\n        self.model: List[YOLOLayer] = nn.ModuleList()\n        self.reg_max = getattr(model_cfg.anchor, \"reg_max\", 16)\n        self.build_model(model_cfg.model)\n\n    def build_model(self, model_arch: Dict[str, List[Dict[str, Dict[str, Dict]]]]):\n        self.layer_index = {}\n        output_dim, layer_idx = [3], 1\n        logger.info(f\":tractor: Building YOLO\")\n        for arch_name in model_arch:\n            if model_arch[arch_name]:\n                logger.info(f\"  :building_construction:  Building {arch_name}\")\n            for layer_idx, layer_spec in enumerate(model_arch[arch_name], start=layer_idx):\n                layer_type, layer_info = next(iter(layer_spec.items()))\n                layer_args = layer_info.get(\"args\", {})\n\n                # Get input source\n                source = self.get_source_idx(layer_info.get(\"source\", -1), layer_idx)\n\n                # Find in channels\n                if any(module in layer_type for module in [\"Conv\", \"ELAN\", \"ADown\", \"AConv\", \"CBLinear\"]):\n                    layer_args[\"in_channels\"] = output_dim[source]\n                if any(module in layer_type for module in [\"Detection\", \"Segmentation\", \"Classification\"]):\n                    if isinstance(source, list):\n                        layer_args[\"in_channels\"] = [output_dim[idx] for idx in source]\n                    else:\n                        layer_args[\"in_channel\"] = output_dim[source]\n                    layer_args[\"num_classes\"] = self.num_classes\n                    layer_args[\"reg_max\"] = self.reg_max\n\n                # create layers\n                layer = self.create_layer(layer_type, source, layer_info, **layer_args)\n                self.model.append(layer)\n\n                if layer.tags:\n                    if layer.tags in self.layer_index:\n                        raise ValueError(f\"Duplicate tag '{layer_info['tags']}' found.\")\n                    self.layer_index[layer.tags] = layer_idx\n\n                out_channels = self.get_out_channels(layer_type, layer_args, output_dim, source)\n                output_dim.append(out_channels)\n                setattr(layer, \"out_c\", out_channels)\n            layer_idx += 1\n\n    def forward(self, x, external: Optional[Dict] = None, shortcut: Optional[str] = None):\n        y = {0: x, **(external or {})}\n        output = dict()\n        for index, layer in enumerate(self.model, start=1):\n            if isinstance(layer.source, list):\n                model_input = [y[idx] for idx in layer.source]\n            else:\n                model_input = y[layer.source]\n\n            external_input = {source_name: y[source_name] for source_name in layer.external}\n\n            x = layer(model_input, **external_input)\n            y[-1] = x\n            if layer.usable:\n                y[index] = x\n            if layer.output:\n                output[layer.tags] = x\n                if layer.tags == shortcut:\n                    return output\n        return output\n\n    def get_out_channels(self, layer_type: str, layer_args: dict, output_dim: list, source: Union[int, list]):\n        if hasattr(layer_args, \"out_channels\"):\n            return layer_args[\"out_channels\"]\n        if layer_type == \"CBFuse\":\n            return output_dim[source[-1]]\n        if isinstance(source, int):\n            return output_dim[source]\n        if isinstance(source, list):\n            return sum(output_dim[idx] for idx in source)\n\n    def get_source_idx(self, source: Union[ListConfig, str, int], layer_idx: int):\n        if isinstance(source, ListConfig):\n            return [self.get_source_idx(index, layer_idx) for index in source]\n        if isinstance(source, str):\n            source = self.layer_index[source]\n        if source < -1:\n            source += layer_idx\n        if source > 0:  # Using Previous Layer's Output\n            self.model[source - 1].usable = True\n        return source\n\n    def create_layer(self, layer_type: str, source: Union[int, list], layer_info: Dict, **kwargs) -> YOLOLayer:\n        if layer_type in self.layer_map:\n            layer = self.layer_map[layer_type](**kwargs)\n            setattr(layer, \"layer_type\", layer_type)\n            setattr(layer, \"source\", source)\n            setattr(layer, \"in_c\", kwargs.get(\"in_channels\", None))\n            setattr(layer, \"output\", layer_info.get(\"output\", False))\n            setattr(layer, \"tags\", layer_info.get(\"tags\", None))\n            setattr(layer, \"external\", layer_info.get(\"external\", []))\n            setattr(layer, \"usable\", 0)\n            return layer\n        else:\n            raise ValueError(f\"Unsupported layer type: {layer_type}\")\n\n    def save_load_weights(self, weights: Union[Path, OrderedDict]):\n        \"\"\"\n        Update the model's weights with the provided weights.\n\n        args:\n            weights: A OrderedDict containing the new weights.\n        \"\"\"\n        if isinstance(weights, Path):\n            weights = torch.load(weights, map_location=torch.device(\"cpu\"), weights_only=False)\n        if \"state_dict\" in weights:\n            weights = {name.removeprefix(\"model.model.\"): key for name, key in weights[\"state_dict\"].items()}\n        model_state_dict = self.model.state_dict()\n\n        # TODO1: autoload old version weight\n        # TODO2: weight transform if num_class difference\n\n        error_dict = {\"Mismatch\": set(), \"Not Found\": set()}\n        for model_key, model_weight in model_state_dict.items():\n            if model_key not in weights:\n                error_dict[\"Not Found\"].add(tuple(model_key.split(\".\")[:-2]))\n                continue\n            if model_weight.shape != weights[model_key].shape:\n                error_dict[\"Mismatch\"].add(tuple(model_key.split(\".\")[:-2]))\n                continue\n            model_state_dict[model_key] = weights[model_key]\n\n        for error_name, error_set in error_dict.items():\n            error_dict = dict()\n            for layer_idx, *layer_name in error_set:\n                if layer_idx not in error_dict:\n                    error_dict[layer_idx] = [\".\".join(layer_name)]\n                else:\n                    error_dict[layer_idx].append(\".\".join(layer_name))\n            for layer_idx, layer_name in error_dict.items():\n                layer_name.sort()\n                logger.warning(f\":warning: Weight {error_name} for Layer {layer_idx}: {', '.join(layer_name)}\")\n\n        self.model.load_state_dict(model_state_dict)", "n_imports_parsed": 8, "n_files_resolved": 2, "n_chars_extracted": 7342}, "tests/test_tools/test_dataset_preparation.py::22": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/dataset_preparation.py"], "used_names": ["Config", "Path", "os", "prepare_dataset", "shutil"], "enclosing_function": "test_prepare_dataset", "extracted_code": "# Source: yolo/config/config.py\nclass Config:\n    task: Union[TrainConfig, InferenceConfig, ValidationConfig]\n    dataset: DatasetConfig\n    model: ModelConfig\n    name: str\n\n    accelerator: Optional[str]\n    device: Union[str, int, List[int]]\n    cpu_num: int\n\n    image_size: List[int]\n\n    out_path: str\n    exist_ok: bool\n\n    lucky_number: 10\n    use_wandb: bool\n    use_tensorboard: bool\n\n    weight: Optional[str]\n\n\n# Source: yolo/tools/dataset_preparation.py\ndef prepare_dataset(dataset_cfg: DatasetConfig, task: str):\n    \"\"\"\n    Prepares dataset by downloading and unzipping if necessary.\n    \"\"\"\n    # TODO: do EDA of dataset\n    data_dir = Path(dataset_cfg.path)\n    for data_type, settings in dataset_cfg.auto_download.items():\n        base_url = settings[\"base_url\"]\n        for dataset_type, dataset_args in settings.items():\n            if dataset_type != \"annotations\" and dataset_cfg.get(task, task) != dataset_type:\n                continue\n            file_name = f\"{dataset_args.get('file_name', dataset_type)}.zip\"\n            url = f\"{base_url}{file_name}\"\n            local_zip_path = data_dir / file_name\n            extract_to = data_dir / data_type if data_type != \"annotations\" else data_dir\n            final_place = extract_to / dataset_type\n\n            final_place.mkdir(parents=True, exist_ok=True)\n            if check_files(final_place, dataset_args.get(\"file_num\")):\n                logger.info(f\":white_check_mark: Dataset {dataset_type: <12} already verified.\")\n                continue\n\n            if not local_zip_path.exists():\n                download_file(url, local_zip_path)\n            unzip_file(local_zip_path, extract_to)\n\n            if not check_files(final_place, dataset_args.get(\"file_num\")):\n                logger.error(f\"Error verifying the {dataset_type} dataset after extraction.\")", "n_imports_parsed": 6, "n_files_resolved": 2, "n_chars_extracted": 1842}, "tests/test_tools/test_data_augmentation.py::70": {"resolved_imports": ["yolo/tools/data_augmentation.py"], "used_names": ["Image", "Mosaic", "torch"], "enclosing_function": "test_mosaic", "extracted_code": "# Source: yolo/tools/data_augmentation.py\nclass Mosaic:\n    \"\"\"Applies the Mosaic augmentation to a batch of images and their corresponding boxes.\"\"\"\n\n    def __init__(self, prob=0.5):\n        self.prob = prob\n        self.parent = None\n\n    def set_parent(self, parent):\n        self.parent = parent\n\n    def __call__(self, image, boxes):\n        if torch.rand(1) >= self.prob:\n            return image, boxes\n\n        assert self.parent is not None, \"Parent is not set. Mosaic cannot retrieve image size.\"\n\n        img_sz = self.parent.base_size  # Assuming `image_size` is defined in parent\n        more_data = self.parent.get_more_data(3)  # get 3 more images randomly\n\n        data = [(image, boxes)] + more_data\n        mosaic_image = Image.new(\"RGB\", (2 * img_sz, 2 * img_sz), (114, 114, 114))\n        vectors = np.array([(-1, -1), (0, -1), (-1, 0), (0, 0)])\n        center = np.array([img_sz, img_sz])\n        all_labels = []\n\n        for (image, boxes), vector in zip(data, vectors):\n            this_w, this_h = image.size\n            coord = tuple(center + vector * np.array([this_w, this_h]))\n\n            mosaic_image.paste(image, coord)\n            xmin, ymin, xmax, ymax = boxes[:, 1], boxes[:, 2], boxes[:, 3], boxes[:, 4]\n            xmin = (xmin * this_w + coord[0]) / (2 * img_sz)\n            xmax = (xmax * this_w + coord[0]) / (2 * img_sz)\n            ymin = (ymin * this_h + coord[1]) / (2 * img_sz)\n            ymax = (ymax * this_h + coord[1]) / (2 * img_sz)\n\n            adjusted_boxes = torch.stack([boxes[:, 0], xmin, ymin, xmax, ymax], dim=1)\n            all_labels.append(adjusted_boxes)\n\n        all_labels = torch.cat(all_labels, dim=0)\n        mosaic_image = mosaic_image.resize((img_sz, img_sz))\n        return mosaic_image, all_labels", "n_imports_parsed": 6, "n_files_resolved": 1, "n_chars_extracted": 1768}, "tests/test_utils/test_module_utils.py::55": {"resolved_imports": ["yolo/utils/module_utils.py"], "used_names": ["divide_into_chunks", "pytest", "re"], "enclosing_function": "test_divide_into_chunks_non_divisible_length", "extracted_code": "# Source: yolo/utils/module_utils.py\ndef divide_into_chunks(input_list, chunk_num):\n    \"\"\"\n    Args: input_list: [0, 1, 2, 3, 4, 5], chunk: 2\n    Return: [[0, 1, 2], [3, 4, 5]]\n    \"\"\"\n    list_size = len(input_list)\n\n    if list_size % chunk_num != 0:\n        raise ValueError(\n            f\"The length of the input list ({list_size}) must be exactly divisible by the number of chunks ({chunk_num}).\"\n        )\n\n    chunk_size = list_size // chunk_num\n    return [input_list[i : i + chunk_size] for i in range(0, list_size, chunk_size)]", "n_imports_parsed": 6, "n_files_resolved": 1, "n_chars_extracted": 538}, "tests/test_model/test_yolo.py::77": {"resolved_imports": ["yolo/config/config.py", "yolo/model/yolo.py"], "used_names": ["torch"], "enclosing_function": "test_yolo_forward_output_shape", "extracted_code": "", "n_imports_parsed": 8, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_tools/test_data_loader.py::72": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["StreamDataLoader"], "enclosing_function": "test_directory_stream_data_loader_frame", "extracted_code": "# Source: yolo/tools/data_loader.py\nclass StreamDataLoader:\n    def __init__(self, data_cfg: DataConfig):\n        self.source = data_cfg.source\n        self.running = True\n        self.is_stream = isinstance(self.source, int) or str(self.source).lower().startswith(\"rtmp://\")\n\n        self.transform = AugmentationComposer([], data_cfg.image_size)\n        self.stop_event = Event()\n\n        if self.is_stream:\n            import cv2\n\n            self.cap = cv2.VideoCapture(self.source)\n        else:\n            self.source = Path(self.source)\n            self.queue = Queue()\n            self.thread = Thread(target=self.load_source)\n            self.thread.start()\n\n    def load_source(self):\n        if self.source.is_dir():  # image folder\n            self.load_image_folder(self.source)\n        elif any(self.source.suffix.lower().endswith(ext) for ext in [\".mp4\", \".avi\", \".mkv\"]):  # Video file\n            self.load_video_file(self.source)\n        else:  # Single image\n            self.process_image(self.source)\n\n    def load_image_folder(self, folder):\n        folder_path = Path(folder)\n        for file_path in folder_path.rglob(\"*\"):\n            if self.stop_event.is_set():\n                break\n            if file_path.suffix.lower() in [\".jpg\", \".jpeg\", \".png\", \".bmp\"]:\n                self.process_image(file_path)\n\n    def process_image(self, image_path):\n        image = Image.open(image_path).convert(\"RGB\")\n        if image is None:\n            raise ValueError(f\"Error loading image: {image_path}\")\n        self.process_frame(image)\n\n    def load_video_file(self, video_path):\n        import cv2\n\n        cap = cv2.VideoCapture(str(video_path))\n        while self.running:\n            ret, frame = cap.read()\n            if not ret:\n                break\n            self.process_frame(frame)\n        cap.release()\n\n    def process_frame(self, frame):\n        if isinstance(frame, np.ndarray):\n            # TODO: we don't need cv2\n            import cv2\n\n            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n            frame = Image.fromarray(frame)\n        origin_frame = frame\n        frame, _, rev_tensor = self.transform(frame, torch.zeros(0, 5))\n        frame = frame[None]\n        rev_tensor = rev_tensor[None]\n        if not self.is_stream:\n            self.queue.put((frame, rev_tensor, origin_frame))\n        else:\n            self.current_frame = (frame, rev_tensor, origin_frame)\n\n    def __iter__(self) -> Generator[Tensor, None, None]:\n        return self\n\n    def __next__(self) -> Tensor:\n        if self.is_stream:\n            ret, frame = self.cap.read()\n            if not ret:\n                self.stop()\n                raise StopIteration\n            self.process_frame(frame)\n            return self.current_frame\n        else:\n            try:\n                frame = self.queue.get(timeout=1)\n                return frame\n            except Empty:\n                raise StopIteration\n\n    def stop(self):\n        self.running = False\n        if self.is_stream:\n            self.cap.release()\n        else:\n            self.thread.join(timeout=1)\n\n    def __len__(self):\n        return self.queue.qsize() if not self.is_stream else 0", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 3190}, "tests/test_tools/test_data_loader.py::47": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["DataLoader", "Path"], "enclosing_function": "test_validation_data_loader_correctness", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_utils/test_module_utils.py::49": {"resolved_imports": ["yolo/utils/module_utils.py"], "used_names": ["divide_into_chunks"], "enclosing_function": "test_divide_into_chunks", "extracted_code": "# Source: yolo/utils/module_utils.py\ndef divide_into_chunks(input_list, chunk_num):\n    \"\"\"\n    Args: input_list: [0, 1, 2, 3, 4, 5], chunk: 2\n    Return: [[0, 1, 2], [3, 4, 5]]\n    \"\"\"\n    list_size = len(input_list)\n\n    if list_size % chunk_num != 0:\n        raise ValueError(\n            f\"The length of the input list ({list_size}) must be exactly divisible by the number of chunks ({chunk_num}).\"\n        )\n\n    chunk_size = list_size // chunk_num\n    return [input_list[i : i + chunk_size] for i in range(0, list_size, chunk_size)]", "n_imports_parsed": 6, "n_files_resolved": 1, "n_chars_extracted": 538}, "tests/test_utils/test_bounding_box_utils.py::114": {"resolved_imports": ["yolo/__init__.py", "yolo/config/config.py", "yolo/utils/bounding_box_utils.py"], "used_names": ["generate_anchors"], "enclosing_function": "test_generate_anchors", "extracted_code": "# Source: yolo/utils/bounding_box_utils.py\ndef generate_anchors(image_size: List[int], strides: List[int]):\n    \"\"\"\n    Find the anchor maps for each w, h.\n\n    Args:\n        image_size List: the image size of augmented image size\n        strides List[8, 16, 32, ...]: the stride size for each predicted layer\n\n    Returns:\n        all_anchors [HW x 2]:\n        all_scalers [HW]: The index of the best targets for each anchors\n    \"\"\"\n    W, H = image_size\n    anchors = []\n    scaler = []\n    for stride in strides:\n        anchor_num = W // stride * H // stride\n        scaler.append(torch.full((anchor_num,), stride))\n        shift = stride // 2\n        h = torch.arange(0, H, stride) + shift\n        w = torch.arange(0, W, stride) + shift\n        if torch.__version__ >= \"2.3.0\":\n            anchor_h, anchor_w = torch.meshgrid(h, w, indexing=\"ij\")\n        else:\n            anchor_h, anchor_w = torch.meshgrid(h, w)\n        anchor = torch.stack([anchor_w.flatten(), anchor_h.flatten()], dim=-1)\n        anchors.append(anchor)\n    all_anchors = torch.cat(anchors, dim=0)\n    all_scalers = torch.cat(scaler, dim=0)\n    return all_anchors, all_scalers\n\nclass Anc2Box:\n    def __init__(self, model: YOLO, anchor_cfg: AnchorConfig, image_size, device):\n        self.device = device\n\n        if hasattr(anchor_cfg, \"strides\"):\n            logger.info(f\":japanese_not_free_of_charge_button: Found stride of model {anchor_cfg.strides}\")\n            self.strides = anchor_cfg.strides\n        else:\n            logger.info(\":teddy_bear: Found no stride of model, performed a dummy test for auto-anchor size\")\n            self.strides = self.create_auto_anchor(model, image_size)\n\n        self.head_num = len(anchor_cfg.anchor)\n        self.anchor_grids = self.generate_anchors(image_size)\n        self.anchor_scale = tensor(anchor_cfg.anchor, device=device).view(self.head_num, 1, -1, 1, 1, 2)\n        self.anchor_num = self.anchor_scale.size(2)\n        self.class_num = model.num_classes\n\n    def create_auto_anchor(self, model: YOLO, image_size):\n        W, H = image_size\n        dummy_input = torch.zeros(1, 3, H, W).to(self.device)\n        dummy_output = model(dummy_input)\n        strides = []\n        for predict_head in dummy_output[\"Main\"]:\n            _, _, *anchor_num = predict_head.shape\n            strides.append(W // anchor_num[1])\n        return strides\n\n    def generate_anchors(self, image_size: List[int]):\n        anchor_grids = []\n        for stride in self.strides:\n            W, H = image_size[0] // stride, image_size[1] // stride\n            anchor_h, anchor_w = torch.meshgrid([torch.arange(H), torch.arange(W)], indexing=\"ij\")\n            anchor_grid = torch.stack((anchor_w, anchor_h), 2).view((1, 1, H, W, 2)).float().to(self.device)\n            anchor_grids.append(anchor_grid)\n        return anchor_grids\n\n    def update(self, image_size):\n        self.anchor_grids = self.generate_anchors(image_size)\n\n    def __call__(self, predicts: List[Tensor]):\n        preds_box, preds_cls, preds_cnf = [], [], []\n        for layer_idx, predict in enumerate(predicts):\n            predict = rearrange(predict, \"B (L C) h w -> B L h w C\", L=self.anchor_num)\n            pred_box, pred_cnf, pred_cls = predict.split((4, 1, self.class_num), dim=-1)\n            pred_box = pred_box.sigmoid()\n            pred_box[..., 0:2] = (pred_box[..., 0:2] * 2.0 - 0.5 + self.anchor_grids[layer_idx]) * self.strides[\n                layer_idx\n            ]\n            pred_box[..., 2:4] = (pred_box[..., 2:4] * 2) ** 2 * self.anchor_scale[layer_idx]\n            preds_box.append(rearrange(pred_box, \"B L h w A -> B (L h w) A\"))\n            preds_cls.append(rearrange(pred_cls, \"B L h w C -> B (L h w) C\"))\n            preds_cnf.append(rearrange(pred_cnf, \"B L h w C -> B (L h w) C\"))\n\n        preds_box = torch.concat(preds_box, dim=1)\n        preds_cls = torch.concat(preds_cls, dim=1)\n        preds_cnf = torch.concat(preds_cnf, dim=1)\n\n        preds_box = transform_bbox(preds_box, \"xycwh -> xyxy\")\n        return preds_cls, None, preds_box, preds_cnf.sigmoid()", "n_imports_parsed": 9, "n_files_resolved": 3, "n_chars_extracted": 4067}, "tests/test_tools/test_loss_functions.py::56": {"resolved_imports": ["yolo/config/config.py", "yolo/model/yolo.py", "yolo/tools/loss_functions.py", "yolo/utils/bounding_box_utils.py"], "used_names": [], "enclosing_function": "test_yolo_loss", "extracted_code": "", "n_imports_parsed": 10, "n_files_resolved": 4, "n_chars_extracted": 0}, "tests/test_tools/test_data_loader.py::63": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["StreamDataLoader"], "enclosing_function": "test_file_stream_data_loader_frame", "extracted_code": "# Source: yolo/tools/data_loader.py\nclass StreamDataLoader:\n    def __init__(self, data_cfg: DataConfig):\n        self.source = data_cfg.source\n        self.running = True\n        self.is_stream = isinstance(self.source, int) or str(self.source).lower().startswith(\"rtmp://\")\n\n        self.transform = AugmentationComposer([], data_cfg.image_size)\n        self.stop_event = Event()\n\n        if self.is_stream:\n            import cv2\n\n            self.cap = cv2.VideoCapture(self.source)\n        else:\n            self.source = Path(self.source)\n            self.queue = Queue()\n            self.thread = Thread(target=self.load_source)\n            self.thread.start()\n\n    def load_source(self):\n        if self.source.is_dir():  # image folder\n            self.load_image_folder(self.source)\n        elif any(self.source.suffix.lower().endswith(ext) for ext in [\".mp4\", \".avi\", \".mkv\"]):  # Video file\n            self.load_video_file(self.source)\n        else:  # Single image\n            self.process_image(self.source)\n\n    def load_image_folder(self, folder):\n        folder_path = Path(folder)\n        for file_path in folder_path.rglob(\"*\"):\n            if self.stop_event.is_set():\n                break\n            if file_path.suffix.lower() in [\".jpg\", \".jpeg\", \".png\", \".bmp\"]:\n                self.process_image(file_path)\n\n    def process_image(self, image_path):\n        image = Image.open(image_path).convert(\"RGB\")\n        if image is None:\n            raise ValueError(f\"Error loading image: {image_path}\")\n        self.process_frame(image)\n\n    def load_video_file(self, video_path):\n        import cv2\n\n        cap = cv2.VideoCapture(str(video_path))\n        while self.running:\n            ret, frame = cap.read()\n            if not ret:\n                break\n            self.process_frame(frame)\n        cap.release()\n\n    def process_frame(self, frame):\n        if isinstance(frame, np.ndarray):\n            # TODO: we don't need cv2\n            import cv2\n\n            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n            frame = Image.fromarray(frame)\n        origin_frame = frame\n        frame, _, rev_tensor = self.transform(frame, torch.zeros(0, 5))\n        frame = frame[None]\n        rev_tensor = rev_tensor[None]\n        if not self.is_stream:\n            self.queue.put((frame, rev_tensor, origin_frame))\n        else:\n            self.current_frame = (frame, rev_tensor, origin_frame)\n\n    def __iter__(self) -> Generator[Tensor, None, None]:\n        return self\n\n    def __next__(self) -> Tensor:\n        if self.is_stream:\n            ret, frame = self.cap.read()\n            if not ret:\n                self.stop()\n                raise StopIteration\n            self.process_frame(frame)\n            return self.current_frame\n        else:\n            try:\n                frame = self.queue.get(timeout=1)\n                return frame\n            except Empty:\n                raise StopIteration\n\n    def stop(self):\n        self.running = False\n        if self.is_stream:\n            self.cap.release()\n        else:\n            self.thread.join(timeout=1)\n\n    def __len__(self):\n        return self.queue.qsize() if not self.is_stream else 0", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 3190}, "tests/test_tools/test_data_loader.py::34": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["DataLoader", "Path"], "enclosing_function": "test_training_data_loader_correctness", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_utils/test_bounding_box_utils.py::127": {"resolved_imports": ["yolo/__init__.py", "yolo/config/config.py", "yolo/utils/bounding_box_utils.py"], "used_names": ["Config", "Vec2Box", "compose", "create_model", "initialize", "torch"], "enclosing_function": "test_vec2box_autoanchor", "extracted_code": "# Source: yolo/__init__.py\nfrom yolo.config.config import Config, NMSConfig\nfrom yolo.model.yolo import create_model\nfrom yolo.tools.data_loader import AugmentationComposer, create_dataloader\nfrom yolo.tools.drawer import draw_bboxes\nfrom yolo.tools.solver import TrainModel\nfrom yolo.utils.bounding_box_utils import Anc2Box, Vec2Box, bbox_nms, create_converter\nfrom yolo.utils.deploy_utils import FastModelLoader\nfrom yolo.utils.logging_utils import (\n    ImageLogger,\n    YOLORichModelSummary,\n\nfrom yolo.config.config import Config, NMSConfig\nfrom yolo.model.yolo import create_model\nfrom yolo.tools.data_loader import AugmentationComposer, create_dataloader\nfrom yolo.tools.drawer import draw_bboxes\nfrom yolo.tools.solver import TrainModel\nfrom yolo.utils.bounding_box_utils import Anc2Box, Vec2Box, bbox_nms, create_converter\nfrom yolo.utils.deploy_utils import FastModelLoader\nfrom yolo.utils.logging_utils import (\n    ImageLogger,\n    YOLORichModelSummary,\n    YOLORichProgressBar,\n\n\nall = [\n    \"create_model\",\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n\nall = [\n    \"create_model\",\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n    \"create_converter\",\n\n    \"Config\",\n    \"YOLORichProgressBar\",\n    \"NMSConfig\",\n    \"YOLORichModelSummary\",\n    \"validate_log_directory\",\n    \"draw_bboxes\",\n    \"Vec2Box\",\n    \"Anc2Box\",\n    \"bbox_nms\",\n    \"create_converter\",\n    \"AugmentationComposer\",\n    \"ImageLogger\",\n\n\n# Source: yolo/utils/bounding_box_utils.py\nclass Vec2Box:\n    def __init__(self, model: YOLO, anchor_cfg: AnchorConfig, image_size, device):\n        self.device = device\n\n        if hasattr(anchor_cfg, \"strides\"):\n            logger.info(f\":japanese_not_free_of_charge_button: Found stride of model {anchor_cfg.strides}\")\n            self.strides = anchor_cfg.strides\n        else:\n            logger.info(\":teddy_bear: Found no stride of model, performed a dummy test for auto-anchor size\")\n            self.strides = self.create_auto_anchor(model, image_size)\n\n        anchor_grid, scaler = generate_anchors(image_size, self.strides)\n        self.image_size = image_size\n        self.anchor_grid, self.scaler = anchor_grid.to(device), scaler.to(device)\n\n    def create_auto_anchor(self, model: YOLO, image_size):\n        W, H = image_size\n        # TODO: need accelerate dummy test\n        dummy_input = torch.zeros(1, 3, H, W)\n        dummy_output = model(dummy_input)\n        strides = []\n        for predict_head in dummy_output[\"Main\"]:\n            _, _, *anchor_num = predict_head[2].shape\n            strides.append(W // anchor_num[1])\n        return strides\n\n    def update(self, image_size):\n        \"\"\"\n        image_size: W, H\n        \"\"\"\n        if self.image_size == image_size:\n            return\n        anchor_grid, scaler = generate_anchors(image_size, self.strides)\n        self.image_size = image_size\n        self.anchor_grid, self.scaler = anchor_grid.to(self.device), scaler.to(self.device)\n\n    def __call__(self, predicts):\n        preds_cls, preds_anc, preds_box = [], [], []\n        for layer_output in predicts:\n            pred_cls, pred_anc, pred_box = layer_output\n            preds_cls.append(rearrange(pred_cls, \"B C h w -> B (h w) C\"))\n            preds_anc.append(rearrange(pred_anc, \"B A R h w -> B (h w) R A\"))\n            preds_box.append(rearrange(pred_box, \"B X h w -> B (h w) X\"))\n        preds_cls = torch.concat(preds_cls, dim=1)\n        preds_anc = torch.concat(preds_anc, dim=1)\n        preds_box = torch.concat(preds_box, dim=1)\n\n        pred_LTRB = preds_box * self.scaler.view(1, -1, 1)\n        lt, rb = pred_LTRB.chunk(2, dim=-1)\n        preds_box = torch.cat([self.anchor_grid - lt, self.anchor_grid + rb], dim=-1)\n        return preds_cls, preds_anc, preds_box", "n_imports_parsed": 9, "n_files_resolved": 3, "n_chars_extracted": 4002}, "tests/test_tools/test_data_loader.py::24": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["Config", "Path", "create_dataloader"], "enclosing_function": "test_create_dataloader_cache", "extracted_code": "# Source: yolo/config/config.py\nclass Config:\n    task: Union[TrainConfig, InferenceConfig, ValidationConfig]\n    dataset: DatasetConfig\n    model: ModelConfig\n    name: str\n\n    accelerator: Optional[str]\n    device: Union[str, int, List[int]]\n    cpu_num: int\n\n    image_size: List[int]\n\n    out_path: str\n    exist_ok: bool\n\n    lucky_number: 10\n    use_wandb: bool\n    use_tensorboard: bool\n\n    weight: Optional[str]\n\n\n# Source: yolo/tools/data_loader.py\ndef create_dataloader(data_cfg: DataConfig, dataset_cfg: DatasetConfig, task: str = \"train\"):\n    if task == \"inference\":\n        return StreamDataLoader(data_cfg)\n\n    if getattr(dataset_cfg, \"auto_download\", False):\n        prepare_dataset(dataset_cfg, task)\n    dataset = YoloDataset(data_cfg, dataset_cfg, task)\n\n    return DataLoader(\n        dataset,\n        batch_size=data_cfg.batch_size,\n        num_workers=data_cfg.cpu_num,\n        pin_memory=data_cfg.pin_memory,\n        collate_fn=collate_fn,\n    )", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 971}, "tests/test_tools/test_data_loader.py::40": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["DataLoader", "Path"], "enclosing_function": "test_training_data_loader_correctness", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_tools/test_data_loader.py::35": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["DataLoader", "Path"], "enclosing_function": "test_training_data_loader_correctness", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_tools/test_data_loader.py::25": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["Config", "Path", "create_dataloader"], "enclosing_function": "test_create_dataloader_cache", "extracted_code": "# Source: yolo/config/config.py\nclass Config:\n    task: Union[TrainConfig, InferenceConfig, ValidationConfig]\n    dataset: DatasetConfig\n    model: ModelConfig\n    name: str\n\n    accelerator: Optional[str]\n    device: Union[str, int, List[int]]\n    cpu_num: int\n\n    image_size: List[int]\n\n    out_path: str\n    exist_ok: bool\n\n    lucky_number: 10\n    use_wandb: bool\n    use_tensorboard: bool\n\n    weight: Optional[str]\n\n\n# Source: yolo/tools/data_loader.py\ndef create_dataloader(data_cfg: DataConfig, dataset_cfg: DatasetConfig, task: str = \"train\"):\n    if task == \"inference\":\n        return StreamDataLoader(data_cfg)\n\n    if getattr(dataset_cfg, \"auto_download\", False):\n        prepare_dataset(dataset_cfg, task)\n    dataset = YoloDataset(data_cfg, dataset_cfg, task)\n\n    return DataLoader(\n        dataset,\n        batch_size=data_cfg.batch_size,\n        num_workers=data_cfg.cpu_num,\n        pin_memory=data_cfg.pin_memory,\n        collate_fn=collate_fn,\n    )", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 971}, "tests/test_tools/test_data_augmentation.py::71": {"resolved_imports": ["yolo/tools/data_augmentation.py"], "used_names": ["Image", "Mosaic", "torch"], "enclosing_function": "test_mosaic", "extracted_code": "# Source: yolo/tools/data_augmentation.py\nclass Mosaic:\n    \"\"\"Applies the Mosaic augmentation to a batch of images and their corresponding boxes.\"\"\"\n\n    def __init__(self, prob=0.5):\n        self.prob = prob\n        self.parent = None\n\n    def set_parent(self, parent):\n        self.parent = parent\n\n    def __call__(self, image, boxes):\n        if torch.rand(1) >= self.prob:\n            return image, boxes\n\n        assert self.parent is not None, \"Parent is not set. Mosaic cannot retrieve image size.\"\n\n        img_sz = self.parent.base_size  # Assuming `image_size` is defined in parent\n        more_data = self.parent.get_more_data(3)  # get 3 more images randomly\n\n        data = [(image, boxes)] + more_data\n        mosaic_image = Image.new(\"RGB\", (2 * img_sz, 2 * img_sz), (114, 114, 114))\n        vectors = np.array([(-1, -1), (0, -1), (-1, 0), (0, 0)])\n        center = np.array([img_sz, img_sz])\n        all_labels = []\n\n        for (image, boxes), vector in zip(data, vectors):\n            this_w, this_h = image.size\n            coord = tuple(center + vector * np.array([this_w, this_h]))\n\n            mosaic_image.paste(image, coord)\n            xmin, ymin, xmax, ymax = boxes[:, 1], boxes[:, 2], boxes[:, 3], boxes[:, 4]\n            xmin = (xmin * this_w + coord[0]) / (2 * img_sz)\n            xmax = (xmax * this_w + coord[0]) / (2 * img_sz)\n            ymin = (ymin * this_h + coord[1]) / (2 * img_sz)\n            ymax = (ymax * this_h + coord[1]) / (2 * img_sz)\n\n            adjusted_boxes = torch.stack([boxes[:, 0], xmin, ymin, xmax, ymax], dim=1)\n            all_labels.append(adjusted_boxes)\n\n        all_labels = torch.cat(all_labels, dim=0)\n        mosaic_image = mosaic_image.resize((img_sz, img_sz))\n        return mosaic_image, all_labels", "n_imports_parsed": 6, "n_files_resolved": 1, "n_chars_extracted": 1768}, "tests/test_tools/test_data_loader.py::26": {"resolved_imports": ["yolo/config/config.py", "yolo/tools/data_loader.py"], "used_names": ["Config", "Path", "create_dataloader"], "enclosing_function": "test_create_dataloader_cache", "extracted_code": "# Source: yolo/config/config.py\nclass Config:\n    task: Union[TrainConfig, InferenceConfig, ValidationConfig]\n    dataset: DatasetConfig\n    model: ModelConfig\n    name: str\n\n    accelerator: Optional[str]\n    device: Union[str, int, List[int]]\n    cpu_num: int\n\n    image_size: List[int]\n\n    out_path: str\n    exist_ok: bool\n\n    lucky_number: 10\n    use_wandb: bool\n    use_tensorboard: bool\n\n    weight: Optional[str]\n\n\n# Source: yolo/tools/data_loader.py\ndef create_dataloader(data_cfg: DataConfig, dataset_cfg: DatasetConfig, task: str = \"train\"):\n    if task == \"inference\":\n        return StreamDataLoader(data_cfg)\n\n    if getattr(dataset_cfg, \"auto_download\", False):\n        prepare_dataset(dataset_cfg, task)\n    dataset = YoloDataset(data_cfg, dataset_cfg, task)\n\n    return DataLoader(\n        dataset,\n        batch_size=data_cfg.batch_size,\n        num_workers=data_cfg.cpu_num,\n        pin_memory=data_cfg.pin_memory,\n        collate_fn=collate_fn,\n    )", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 971}, "tests/test_model/test_module.py::22": {"resolved_imports": ["yolo/model/module.py"], "used_names": ["Conv", "torch"], "enclosing_function": "test_conv", "extracted_code": "# Source: yolo/model/module.py\nclass Conv(nn.Module):\n    \"\"\"A basic convolutional block that includes convolution, batch normalization, and activation.\"\"\"\n\n    def __init__(\n        self,\n        in_channels: int,\n        out_channels: int,\n        kernel_size: _size_2_t,\n        *,\n        activation: Optional[str] = \"SiLU\",\n        **kwargs,\n    ):\n        super().__init__()\n        kwargs.setdefault(\"padding\", auto_pad(kernel_size, **kwargs))\n        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, bias=False, **kwargs)\n        self.bn = nn.BatchNorm2d(out_channels, eps=1e-3, momentum=3e-2)\n        self.act = create_activation_function(activation)\n\n    def forward(self, x: Tensor) -> Tensor:\n        return self.act(self.bn(self.conv(x)))", "n_imports_parsed": 4, "n_files_resolved": 1, "n_chars_extracted": 764}}}