Ինչպես ես դարձրեցի օբյեկտների հայտնաբերումն ավելի խելացի ինքնակառավարվող մեքենաների համար՝ Transfer Learning և ASPP

Ինքնավար մեքենաները չեն կարող իրենց թույլ տալ սխալներ. Լուսացույցի կամ հետիոտնի բաց թողնելը կարող է աղետ նշանակել։ Բայց օբյեկտների հայտնաբերումը դինամիկ քաղաքային միջավայրո՞ւմ: Դա դժվար է:

Ես աշխատել եմ ինքնավար մեքենաների օբյեկտների հայտնաբերման օպտիմիզացման վրա՝ օգտագործելով Atrous Spatial Pyramid Pooling (ASPP) և Transfer Learning: Արդյունքը. Մոդել, որը հայտնաբերում է առարկաները մի քանի մասշտաբներով, նույնիսկ վատ լուսավորության պայմաններում, և արդյունավետորեն աշխատում է իրական ժամանակում:

Ահա թե ինչպես ես դա արեցի.

Խնդիր. Օբյեկտների հայտնաբերում վայրի բնության մեջ

Ինքնավար մեքենաները հիմնվում են կոնվոլյուցիոն նեյրոնային ցանցերի վրա (CNN)՝ օբյեկտները հայտնաբերելու համար, սակայն իրական աշխարհի պայմանները մարտահրավերներ են ներկայացնում.

• Լուսացույցները հայտնվում են տարբեր մասշտաբներով ՝ փոքր, երբ հեռու է, մեծ, երբ մոտ է:
• Գոտիների գծանշումները աղավաղվում են տարբեր անկյուններից:
• Խցանումներ են տեղի ունենում . կայանված մեքենայի հետևում գտնվող հետիոտնը կարող է բաց թողնել:
• Լուսավորության պայմանները տարբեր են ՝ ստվերներ, փայլ կամ գիշերային վարում:

Ավանդական CNN-ները պայքարում են բազմամասշտաբ օբյեկտների հայտնաբերման դեմ, և զրոյից ուսուցումը հավերժ է տևում: Ահա թե որտեղ են ASPP-ը և Transfer Learning-ը :

ASPP. Տարբեր մասշտաբներով օբյեկտների գրավում

CNN-ները լավ են աշխատում ֆիքսված չափի օբյեկտների համար, սակայն իրական աշխարհի օբյեկտները տարբերվում են չափերով և հեռավորությամբ: Atrous Spatial Pyramid Pooling-ը (ASPP) լուծում է դա՝ օգտագործելով լայնացած ոլորումներ ՝ մի քանի մասշտաբներով առանձնահատկությունները գրավելու համար:

Ինչպես է աշխատում ASPP-ը

ASPP-ն կիրառում է մի քանի ոլորման ֆիլտրեր՝ տարբեր լայնացման արագությամբ՝ տարբեր լուծաչափերով, փոքր օբյեկտների, մեծ առարկաների և միջև եղած ամեն ինչ հանելու համար:

Ահա, թե ինչպես եմ ես իրականացրել ASPP-ը PyTorch-ում՝ ներառելով խմբի նորմալացում և ուշադրություն բարդ միջավայրերում կայուն կատարման համար.

 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

Ինչու է այն աշխատում

• Տարբեր ընդունող դաշտերը մոդելին թույլ են տալիս մեկ անցումով վերցնել փոքր առարկաներ (ինչպես հեռավոր լուսացույցի) և մեծ առարկաներ (ինչպես ավտոբուս):
• Համաշխարհային միջին համախմբման ճյուղի գլոբալ համատեքստն օգնում է անհասկանալի դարձնել օբյեկտները:
• Թեթև ուշադրությունը ընդգծում է ամենատեղեկատվական ալիքները՝ բարձրացնելով հայտնաբերման ճշգրտությունը խառնաշփոթ տեսարաններում:

Արդյունքները:

• Հայտնաբերված առարկաներ տարբեր մասշտաբներով (այլևս բացակայում են փոքր լուսացույցները):
• Բարելավվել է միջին միջին ճշգրտությունը (mAP) 14%-ով:
• Ավելի լավ է կառավարում խցանումները ՝ հայտնաբերելով մասամբ թաքնված առարկաները:

Տրանսֆերային ուսուցում. կանգնել հսկաների ուսերին

Օբյեկտների հայտնաբերման մոդելի զրոյից ուսուցումը մեծ օգուտ չի տալիս, երբ կան նախապես պատրաստված մոդելներ: Տրանսֆերային ուսուցումը մեզ թույլ է տալիս ճշգրտել մոդելը, որն արդեն հասկանում է օբյեկտները:

Ես օգտագործել եմ DETR (Detection Transformer)՝ տրանսֆորմատորի վրա հիմնված օբյեկտների հայտնաբերման մոդել Facebook AI-ից: Այն սովորում է համատեքստը, ուստի ոչ միայն կանգառի նշան է գտնում, այլ հասկանում է, որ դա ճանապարհային տեսարանի մի մասն է:

Ահա, թե ինչպես ես ճշգրտեցի DETR-ը ինքնակառավարվող տվյալների հավաքածուներում.

 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)

Արդյունքները:

• Կրճատվել է մարզման ժամանակը 80%-ով:
• Գիշերային և մառախլապատ պայմաններում իրական աշխարհի կատարողականության բարելավում:
• Վերապատրաստման համար ավելի քիչ պիտակավորված տվյալներ են անհրաժեշտ:

Տվյալների խթանում սինթետիկ պատկերներով

Ինքնավար մեքենաներին անհրաժեշտ են տվյալների զանգվածային հավաքածուներ, սակայն իրական աշխարհի պիտակավորված տվյալները քիչ են: Ուղղումը. Ստեղծեք սինթետիկ տվյալներ՝ օգտագործելով GANs (Generative Adversarial Networks):

Ես օգտագործել եմ GAN՝ ստեղծելու կեղծ, բայց իրատեսական գծանշումներ և երթևեկության տեսարաններ ՝ տվյալների բազան ընդլայնելու համար:

Ահա մի պարզ GAN՝ գոտիների գծանշման առաջացման համար.

 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)

Արդյունքները:

• Տվյալների տվյալների չափն ավելացել է 5 անգամ՝ առանց ձեռքով պիտակավորման:
• Վերապատրաստված մոդելները դարձան ավելի ամուր եզրային պատյաններ:
• Նվազեցված կողմնակալություն տվյալների հավաքածուներում (ավելի բազմազան ուսուցման նմուշներ):

Վերջնական արդյունքներ. Ավելի խելացի, ավելի արագ օբյեկտների հայտնաբերում

Համատեղելով ASPP-ը, Transfer Learning-ը և Synthetic Data-ը ՝ ես կառուցել եմ օբյեկտների հայտնաբերման ավելի ճշգրիտ, մասշտաբային համակարգ ինքնակառավարվող մեքենաների համար: Հիմնական արդյունքներից մի քանիսն են.

• Օբյեկտների հայտնաբերման արագություն ՝ 110 մս/կադր
• Փոքր օբյեկտների հայտնաբերում (երթևեկության լույսեր) ՝ +14% mAP
• Occlusion Handling . Ավելի կայուն հայտնաբերում
• Դասընթացի տևողությունը ՝ կրճատվել է մինչև 6 ժամ
• Պահանջվող վերապատրաստման տվյալներ ՝ 50% սինթետիկ (GANs)

Հաջորդ քայլերը. Դարձնել այն էլ ավելի լավը

• Իրական ժամանակի հետագծման ավելացում՝ ժամանակի ընթացքում հայտնաբերված օբյեկտներին հետևելու համար:
• Օգտագործելով ավելի առաջադեմ տրանսֆորմատորներ (ինչպես OWL-ViT) զրոյական կրակոցի հայտնաբերման համար:
• Եզրակացությունների արագության հետագա օպտիմիզացում՝ ներկառուցված սարքավորումների վրա տեղակայման համար:

Եզրակացություն

Մենք միավորեցինք ASPP-ը, տրանսֆորմատորները և սինթետիկ տվյալները՝ դառնալով օբյեկտների ինքնավար հայտնաբերման եռակի սպառնալիք՝ երբեմնի դանդաղ, կույր կետերին հակված մոդելները վերածելով արագ, ընկալունակ համակարգերի, որոնք նկատում են լուսացույցը մեկ թաղամասից հեռու: Ընդգրկելով լայնածավալ պտույտները բազմամասշտաբ մանրամասների համար, փոխանցելով ուսուցումը արագ ճշգրտման համար և GAN-ի կողմից ստեղծված տվյալները՝ յուրաքանչյուր բացը լրացնելու համար, մենք կրճատեցինք եզրակացության ժամանակը գրեթե կիսով չափ և խնայեցինք ուսուցման ժամերը: Սա մեծ թռիչք է դեպի այն մեքենաները, որոնք աշխարհին ավելի շատ են տեսնում, ինչպես մենք, միայն ավելի արագ, ավելի ճշգրիտ, և մեր ամենաքաոսային փողոցներով վստահորեն նավարկելու ճանապարհին:

Որոշ տեխնիկայի վերաբերյալ լրացուցիչ ընթերցում

• DETR. Օբյեկտների վերջնական հայտնաբերում
• Atrous convolutions իմաստային հատվածի համար
• GAN-ներ սինթետիկ տվյալների համար