Chýbajúci semafor alebo chodec môže znamenať katastrofu. Ale detekcia objektov v dynamickom mestskom prostredí? To je Samoriadiace autá si chyby nemôžu dovoliť. ťažké. Pracoval som na optimalizácii detekcie objektov pre autonómne vozidlá pomocou Výsledok? Atrous Spatial Pyramid Pooling (ASPP) a Transfer Learning. Model, ktorý rozpoznáva objekty vo viacerých mierkach, dokonca aj pri zlom osvetlení, a efektívne beží v reálnom čase. Tu je návod, ako som to urobil. Problém: Detekcia objektov vo voľnej prírode Autá s vlastným pohonom sa pri detekcii objektov spoliehajú na , no podmienky v reálnom svete prinášajú konvolučné neurónové siete (CNN) výzvy: – malé, keď sú ďaleko, veľké, keď sú blízko. Semafory sa zobrazujú v rôznych mierkach v rôznych uhloch. Značenie jazdných pruhov sa zdeformuje - chodec za zaparkovaným autom môže byť prehliadnutý. Dochádza k upchatiu – tiene, oslnenie alebo nočná jazda. Svetelné podmienky sa líšia Tradičné CNN bojujú s a školenie od začiatku trvá večnosť. Tu prichádza na rad . detekciou objektov vo viacerých mierkach ASPP a Transfer Learning ASPP: Snímanie objektov v rôznych mierkach CNN fungujú dobre pre ale objekty v reálnom svete to rieši pomocou na objekty s pevnou veľkosťou, sa líšia veľkosťou a vzdialenosťou. Atrous Spatial Pyramid Pooling (ASPP) rozšírených konvolúcií zachytenie prvkov vo viacerých mierkach. Ako funguje ASPP ASPP používa viacero na extrahovanie prvkov v rôznych rozlíšeniach, malé objekty, veľké objekty a všetko medzi tým. konvolučných filtrov s rôznymi rýchlosťami dilatácie Tu je návod, ako som implementoval ASPP v PyTorch, ktorý zahŕňa normalizáciu skupiny a pozornosť na robustný výkon v zložitých prostrediach: import torch import torch.nn as nn import torch.nn.functional as F class ASPP(nn.Module): """ A more advanced ASPP with optional attention and group normalization. """ def __init__(self, in_channels, out_channels, dilation_rates=(6,12,18), groups=8): super(ASPP, self).__init__() self.aspp_branches = nn.ModuleList() #1x1 Conv branch self.aspp_branches.append( nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False), nn.GroupNorm(groups, out_channels), nn.ReLU(inplace=True) ) ) for rate in dilation_rates: self.aspp_branches.append( nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=rate, dilation=rate, bias=False), nn.GroupNorm(groups, out_channels), nn.ReLU(inplace=True) ) ) #Global average pooling branch self.global_pool = nn.AdaptiveAvgPool2d((1, 1)) self.global_conv = nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=False), nn.GroupNorm(groups, out_channels), nn.ReLU(inplace=True) ) #Attention mechanism to refine the concatenated features self.attention = nn.Sequential( nn.Conv2d(out_channels*(len(dilation_rates)+2), out_channels, kernel_size =1, bias=False), nn.Sigmoid() ) self.project = nn.Sequential( nn.Conv2d(out_channels*(len(dilation_rates)+2), out_channels, kernel_size=1, bias=False), nn.GroupNorm(groups, out_channels), nn.ReLU(inplace=True) ) def forward(self, x): cat_feats = [] for branch in self.aspp_branches: cat_feats.append(branch(x)) g_feat = self.global_pool(x) g_feat = self.global_conv(g_feat) g_feat = F.interpolate(g_feat, size=x.shape[2:], mode='bilinear', align_corners=False) cat_feats.append(g_feat) #Concatenate along channels x_cat = torch.cat(cat_feats, dim=1) #channel-wise attention att_map = self.attention(x_cat) x_cat = x_cat * att_map out = self.project(x_cat) return out Prečo to funguje Rozmanité vnímavé polia umožňujú modelu zachytiť malé predmety (napríklad vzdialený semafor) a veľké predmety (napríklad autobus) v jednom prejazde. Globálny kontext z globálnej priemernej združovacej vetvy pomáha rozlíšiť objekty. Nízka pozornosť kladie dôraz na najinformatívnejšie kanály, čím sa zvyšuje presnosť detekcie v neprehľadných scénach. Výsledky: (už žiadne chýbajúce malé semafory). Rozpoznané objekty v rôznych mierkach Zlepšená stredná priemerná presnosť (mAP) o 14 %. a detegoval čiastočne skryté objekty. Lepšie zvládal oklúzie Transfer Learning: Stáť na ramenách obrov Trénovanie modelu detekcie objektov od začiatku neposkytuje veľa výhod, ak existujú vopred pripravené modely. nám umožňuje model, ktorý už rozumie objektom. Prenosové učenie doladiť Použil som od Facebooku AI. Učí sa kontext – takže nielen nájde stopku, ale pochopí, že je súčasťou cestnej scény. DETR (Detection Transformer), model detekcie objektov založený na transformátore Tu je návod, ako som doladil DETR na množinách údajov s vlastným pohonom: import torch import torch.nn as nn from transformers import DetrConfig, DetrForObjectDetection class CustomBackbone(nn.Module): def __init__(self, in_channels=3, hidden_dim=256): super(CustomBackbone, self).__init__() # Example: basic conv layers + ASPP self.initial_conv = nn.Sequential( nn.Conv2d(in_channels, 64, kernel_size=7, stride=2, padding=3, bias=False), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=3, stride=2, padding=1) ) self.aspp = ASPP(in_channels=64, out_channels=hidden_dim) def forward(self, x): x = self.initial_conv(x) x = self.aspp(x) return x class DETRWithASPP(nn.Module): def __init__(self, num_classes=91): super(DETRWithASPP, self).__init__() self.backbone = CustomBackbone() config = DetrConfig.from_pretrained("facebook/detr-resnet-50") config.num_labels = num_classes self.detr = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50", config=config) self.detr.model.backbone.body = nn.Identity() def forward(self, images, pixel_masks=None): features = self.backbone(images) feature_dict = { "0": features } outputs = self.detr.model(inputs_embeds=None, pixel_values=None, pixel_mask=pixel_masks, features=feature_dict, output_attentions=False) return outputs model = DETRWithASPP(num_classes=10) images = torch.randn(2, 3, 512, 512) outputs = model(images) Výsledky: Skrátený čas tréningu o 80%. Vylepšený výkon v reálnom svete v noci a v hmle. Na školenie je potrebných menej označených údajov. Posilnenie údajov pomocou syntetických obrázkov Autonómne vozidlá potrebujú obrovské súbory údajov, no reálne označených údajov je málo. Oprava? Generujte syntetické dáta pomocou GAN (Generative Adversarial Networks). Použil som GAN na vytvorenie na . falošného, ale realistického značenia jazdných pruhov a dopravných scén rozšírenie súboru údajov Tu je jednoduchý GAN na generovanie značenia jazdných pruhov: import torch import torch.nn as nn import torch.nn.functional as F class LaneMarkingGenerator(nn.Module): """ A DCGAN-style generator designed for producing synthetic lane or road-like images. Input is a latent vector (noise), and the output is a (1 x 64 x 64) grayscale image. You can adjust channels, resolution, and layers to match your target data. """ def __init__(self, z_dim=100, feature_maps=64): super(LaneMarkingGenerator, self).__init__() self.net = nn.Sequential( #Z latent vector of shape (z_dim, 1, 1) nn.utils.spectral_norm(nn.ConvTranspose2d(z_dim, feature_maps * 8, 4, 1, 0, bias=False)), nn.BatchNorm2d(feature_maps * 8), nn.ReLU(True), #(feature_maps * 8) x 4 x 4 nn.utils.spectral_norm(nn.ConvTranspose2d(feature_maps * 8, feature_maps * 4, 4, 2, 1, bias=False)), nn.BatchNorm2d(feature_maps * 4), nn.ReLU(True), #(feature_maps * 4) x 8 x 8 nn.utils.spectral_norm(nn.ConvTranspose2d(feature_maps * 4, feature_maps * 2, 4, 2, 1, bias=False)), nn.BatchNorm2d(feature_maps * 2), nn.ReLU(True), #(feature_maps * 2) x 16 x 16 nn.utils.spectral_norm(nn.ConvTranspose2d(feature_maps * 2, feature_maps, 4, 2, 1, bias=False)), nn.BatchNorm2d(feature_maps), nn.ReLU(True), #(feature_maps) x 32 x 32 nn.utils.spectral_norm(nn.ConvTranspose2d(feature_maps, 1, 4, 2, 1, bias=False)), nn.Tanh() ) def forward(self, z): return self.net(z) class LaneMarkingDiscriminator(nn.Module): """ A DCGAN-style discriminator. It takes a (1 x 64 x 64) image and attempts to classify whether it's real or generated (fake). """ def __init__(self, feature_maps=64): super(LaneMarkingDiscriminator, self).__init__() self.net = nn.Sequential( #1x 64 x 64 nn.utils.spectral_norm(nn.Conv2d(1, feature_maps, 4, 2, 1, bias=False)), nn.LeakyReLU(0.2, inplace=True), #(feature_maps) x 32 x 32 nn.utils.spectral_norm(nn.Conv2d(feature_maps, feature_maps * 2, 4, 2, 1, bias=False)), nn.BatchNorm2d(feature_maps * 2), nn.LeakyReLU(0.2, inplace=True), #(feature_maps * 2) x 16 x 16 nn.utils.spectral_norm(nn.Conv2d(feature_maps * 2, feature_maps * 4, 4, 2, 1, bias=False)), nn.BatchNorm2d(feature_maps * 4), nn.LeakyReLU(0.2, inplace=True), #(feature_maps * 4) x 8 x 8 nn.utils.spectral_norm(nn.Conv2d(feature_maps * 4, feature_maps * 8, 4, 2, 1, bias=False)), nn.BatchNorm2d(feature_maps * 8), nn.LeakyReLU(0.2, inplace=True), #(feature_maps * 8) x 4 x 4 nn.utils.spectral_norm(nn.Conv2d(feature_maps * 8, 1, 4, 1, 0, bias=False)), ) def forward(self, x): return self.net(x).view(-1) Výsledky: 5x väčšia veľkosť súboru údajov bez manuálneho označovania. Trénované modely sa stali robustnejšími až po okrajové puzdrá. Znížená odchýlka v súboroch údajov (rozmanitejšie tréningové vzorky). Konečné výsledky: Inteligentnejšia a rýchlejšia detekcia objektov Kombináciou som vytvoril presnejší, škálovateľný systém detekcie objektov pre autonómne autá. Niektoré z kľúčových výsledkov sú: ASPP, prenosu učenia a syntetických údajov : 110 ms/snímok Rýchlosť detekcie objektu : +14 % mAP Detekcia malých objektov (semafory) : Robustnejšia detekcia Spracovanie oklúzie : Skrátený na 6 hodín Čas tréningu : 50 % syntetické (GAN) Požadované tréningové údaje Ďalšie kroky: Ešte lepšie na sledovanie detekovaných objektov v priebehu času. Pridanie sledovania v reálnom čase Použitie pokročilejších transformátorov (ako OWL-ViT) na detekciu nulového výstrelu. Ďalšia optimalizácia rýchlosti odvodenia pre nasadenie na vstavanom hardvéri. Záver Zlúčili sme ASPP, Transformers a Synthetic Data do trojitej hrozby pre autonómnu detekciu objektov – premenili sme kedysi pomalé modely náchylné na slepé uhly na rýchle a vnímavé systémy, ktoré zbadajú semafor z bloku ďalej. Zahrnutím rozšírených konvolúcií pre viacrozmerné detaily, prenosu učenia pre rýchle jemné ladenie a údajov generovaných GAN na vyplnenie každej medzery sme skrátili časy odvodenia takmer na polovicu a ušetrili hodiny školenia. Je to veľký skok smerom k autám, ktoré vidia svet skôr tak, ako my, len rýchlejšie, presnejšie a sú na ceste k sebavedomému pohybu po našich najchaotickejších uliciach. Ďalšie čítanie o niektorých technikách DETR: End-to-End Object Detection Atrous Convolutions for Semantic Segmentation GAN pre syntetické dáta
