Լուսացույցի կամ հետիոտնի բաց թողնելը կարող է աղետ նշանակել։ Բայց օբյեկտների հայտնաբերումը դինամիկ քաղաքային միջավայրո՞ւմ: Դա Ինքնավար մեքենաները չեն կարող իրենց թույլ տալ սխալներ. դժվար է: Ես աշխատել եմ ինքնավար մեքենաների օբյեկտների հայտնաբերման օպտիմիզացման վրա՝ օգտագործելով Արդյունքը. 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%-ով: ՝ հայտնաբերելով մասամբ թաքնված առարկաները: Ավելի լավ է կառավարում խցանումները Տրանսֆերային ուսուցում. կանգնել հսկաների ուսերին Օբյեկտների հայտնաբերման մոդելի զրոյից ուսուցումը մեծ օգուտ չի տալիս, երբ կան նախապես պատրաստված մոդելներ: մեզ թույլ է տալիս մոդելը, որն արդեն հասկանում է օբյեկտները: Տրանսֆերային ուսուցումը ճշգրտել Ես օգտագործել եմ Facebook AI-ից: Այն սովորում է համատեքստը, ուստի ոչ միայն կանգառի նշան է գտնում, այլ հասկանում է, որ դա ճանապարհային տեսարանի մի մասն է: DETR (Detection Transformer)՝ տրանսֆորմատորի վրա հիմնված օբյեկտների հայտնաբերման մոդել Ահա, թե ինչպես ես ճշգրտեցի 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-ներ սինթետիկ տվյալների համար
