Как правильно реализовать и отладить якоря RPN в ResNet-18 для многократного обнаружения объектов?

Я работаю над своим первым проектом по обнаружению объектов и мне нужно реализовать обнаружение нескольких объектов, используя ResNet-18 (я ограничен использованием этой архитектуры). Мой набор данных соответствует формату COCO и содержит изображения с одной или несколькими акулами, а также некоторые изображения без акул (но большинство из них содержат одну акулу).

Поскольку ResNet-18 не поддерживает нативное обнаружение нескольких объектов, я понимаю, что мне нужно интегрировать RPN (Сеть Предложений Регионов). Однако, в отличие от ResNet-50, ResNet-18 не имеет встроенной реализации в Torchvision, поэтому я попытался вручную реализовать anchor_generator.

Мне удалось сгенерировать анкерные боксы, но я не уверен, прав ли мой подход.
Ключевые вопросы:

Как можно проверить правильность моей реализации generate_anchors?
Как я могу убедиться, что созданные якоря правильно согласованы с ожиданиями RPN?
Существуют ли рекомендованные методы отладки для проверки, имеют ли смысл предложения якорей до начала обучения?

Ниже я прикрепляю мою реализацию для Dataset, модификацию ResNet-18 с якорями и мою попытку интеграции RPN.

from google.colab import drive
drive.mount('/content/drive')

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import models, transforms
from torch.utils.data import Dataset, DataLoader
from torch.utils.tensorboard import SummaryWriter
import json
from PIL import Image
import os
import torch
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import torch
import torchvision.transforms as T
import matplotlib.pyplot as plt
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from PIL import Image
import json
import os
import torch.optim as optim
from torch.optim.lr_scheduler import StepLR

import albumentations
print(albumentations.__version__)

import torch
from torch.utils.data import Dataset, DataLoader
import albumentations as A
from albumentations.pytorch import ToTensorV2
import json
import os
import numpy as np
from PIL import Image

class SharksDataset(Dataset):
   
    def __init__(self, images_dir, json_file, transform=None):
        with open(json_file, 'r') as f:
            self.coco = json.load(f)
        self.images_dir = images_dir
        self.transform = transform

       
        ann_map = {}
        for ann in self.coco['annotations']:
            img_id = ann['image_id']
            ann_map.setdefault(img_id, []).append(ann)

        self.images = self.coco['images']
        self.annotations = ann_map

    def __len__(self):
        return len(self.images)

    def __getitem__(self, idx):
        img_info = self.images[idx]
        img_id = img_info['id']
        filename = img_info['file_name']
        img_path = os.path.join(self.images_dir, filename)

        image = np.array(Image.open(img_path).convert("RGB"))
        anns = self.annotations.get(img_id, [])

        boxes = []
        labels = []
        for ann in anns:
            x, y, w, h = ann['bbox']
            
            boxes.append([x, y, x + w, y + h])
            
            labels.append(1)

        if self.transform:
            transformed = self.transform(image=image, bboxes=boxes, class_labels=labels)
            image_out = transformed['image']
            boxes_out = transformed['bboxes']
            labels_out = transformed['class_labels']
        else:
            image_out = torch.from_numpy(image).permute(2,0,1).float()
            boxes_out = boxes
            labels_out = labels

        boxes_out = torch.tensor(boxes_out, dtype=torch.float32)
        labels_out = torch.tensor(labels_out, dtype=torch.long)

        return image_out, boxes_out, labels_out, filename

def shark_collate_fn(batch):
    
    images = []
    all_boxes = []
    all_labels = []
    filenames = []
    for (img, b, lbl, fname) in batch:
        images.append(img)
        all_boxes.append(b)
        all_labels.append(lbl)
        filenames.append(fname)

    images = torch.stack(images, dim=0)
    return images, all_boxes, all_labels, filenames

import torch
import torch.nn as nn
import torchvision

class SimpleAnchorResnet18(nn.Module):
    
    def __init__(self, num_anchors=9, num_classes=2):
        super().__init__()
        backbone = torchvision.models.resnet18(weights="IMAGENET1K_V1")
        self.backbone = nn.Sequential(*list(backbone.children())[:-2])
        self.in_channels = 512
        self.num_anchors = num_anchors
        self.num_classes = num_classes

        
        self.cls_head  = nn.Conv2d(self.in_channels, self.num_anchors*self.num_classes, kernel_size=1)
        
        self.bbox_head = nn.Conv2d(self.in_channels, self.num_anchors*4, kernel_size=1)

    def forward(self, x):
        feats = self.backbone(x)        # [B,512,H',W']
        cls_out  = self.cls_head(feats) # [B,2*nAnchors,H',W']
        bbox_out = self.bbox_head(feats)# [B,4*nAnchors,H',W']
        return cls_out, bbox_out

import torchvision
import torch.nn as nn
import torchvision.models as models
from torchvision.models.detection import FasterRCNN
from torchvision.models.detection.rpn import AnchorGenerator


backbone = models.resnet18(weights="IMAGENET1K_V1")  
backbone = nn.Sequential(*list(backbone.children())[:-2])  


backbone.out_channels = 512


anchor_generator = AnchorGenerator(
    sizes=((32, 64, 128, 256, 512),),  
    aspect_ratios=((0.5, 1.0, 2.0),) * 5 

roi_pooler = torchvision.ops.MultiScaleRoIAlign(
    featmap_names=["0"], output_size=7, sampling_ratio=2
)


model = FasterRCNN(
    backbone,
    num_classes=2,  
    rpn_anchor_generator=anchor_generator,
    box_roi_pool=roi_pooler
)

print(model)