Featureudtræk: Frysning af backbone

Transfer learning har to hovedstrategier. Ved feature-ekstraktion er den forudtrænede backbone-model fuldstændig frosset — dens vægte ændres ikke under træningen. Kun det nye klassifikationshoved, som du tilføjer ovenpå, lærer fra dine data. Ved finjustering opdateres hele netværket eller i det mindste nogle af backbone-lagene også.

Feature-ekstraktion er det rigtige valg, når dit datasæt er lille (mindre end nogle få tusinde billeder), eller når dine billeder er lignende ImageNet (naturlige fotografier af hverdagsobjekter). Det er meget hurtigere, eftersom gradienter ikke flyder gennem backbone-modellen, og det undgår at ødelægge omhyggeligt indlærte egenskaber med støjende opdateringer fra for få data.

I PyTorch har hver parametertensor en requires_grad-attribut. Hvis du sætter den til False, forhindres gradientberegning for denne tensor, så den reelt fryses. Den enkleste måde at fryse alle backbone-parametre på er at gennemløbe model.parameters() og sætte requires_grad = False og derefter erstatte klassifikationshovedet (som starter med nye tilfældige vægte, så requires_grad=True som standard).

Dette er effektivt: PyTorchs autograd springer frosne parametre over under det baglæns gennemløb, hvilket reducerer hukommelsesforbruget og gør træningen betydeligt hurtigere sammenlignet med finjustering af hele netværket.

ImageNet-forudtrænede modeller lærer et hierarki af features: Tidlige lag registrerer kanter og farver på lavt niveau, mellemste lag registrerer teksturer og dele, og senere lag registrerer abstrakte objekter. Disse features er generelle visuelle features, som kan overføres bredt på tværs af billeddomæner.

Når din opgave omfatter naturlige billeder — blomster, dyr, medicinske scanninger eller satellitfotos — er disse forudlærte features langt mere informative end noget, et tilfældigt initialiseret netværk kunne udtrække fra et lille datasæt. Feature-ekstraktion udnytter dette ved at behandle den frosne backbone-model som en fast featuretransformer og kun træne en lille lineær klassifikator oven på de udtrukne features.

Når funktionerne er fastfrosset, går træningen hurtigt. Optimeringsalgoritmen opdaterer kun vægtene i det nye hoved. Du kan enten træne et simpelt nn.Linear-lag i PyTorch eller endda sende de allerede udtrukne funktionsvektorer til scikit-learns LogisticRegression eller SVC — begge tilgange fungerer godt til lineær klassifikation oven på omfattende fortrænede funktioner.

Brug af et enkelt lineært lag svarer til at træne en logistisk regression på de udtrukne funktioner. Til mere komplekse opgaver, eller når dine klasser kræver ikke-lineære beslutningsgrænser, kan du bruge et lille flerlags-hoved med ReLU-aktiveringer og dropout mellem det fastfrosne grundnetværk og outputtet.

Under funktionsudtrækningen skal billedforbehandlingen svare til de transformationer, der blev brugt ved træningen af den oprindelige model. For fortrænede ImageNet-modeller betyder det: tilpas størrelsen til 256, beskær centreret til 224×224, konvertér til tensor, og normalisér med ImageNets middelværdi og standardafvigelse.

Når du bruger weights.transforms(), leverer PyTorch automatisk den korrekte forbehandlingspipeline, der er knyttet til netop disse vægte. Det eliminerer en almindelig kilde til svære fejl, hvor du ved et uheld bruger forkerte normaliseringskonstanter, hvilket kan reducere nøjagtigheden ved overførselslæring med flere procentpoint.

Funktionsudtrækning er markant hurtigere end fuld finjustering. Når alle parametre i grundnetværket har requires_grad=False, beregner PyTorch ikke gradienter gennem dem under loss.backward(), hvilket sparer hukommelse og beregningstid proportionalt med antallet af fastfrosne lag.

For ResNet-50 (25M parametre, 2048 fastfrosne funktioner og kun omkring 2K parametre i hovedet) gennemføres en træningsepoke på et datasæt med 5000 billeder på sekunder på CPU, sammenlignet med minutter ved fuld finjustering. Det går endnu hurtigere at udtrække funktionerne offline på forhånd og derefter kun træne hovedet som en almindelig sklearn-klassifikator, eftersom grundnetværkets fremadrettede beregning kun køres én gang pr. billede.

Tilgangen er den samme for EfficientNet: fastfrys alle parametre, og erstat derefter det endelige klassifikationslag. I EfficientNet er klassifikatoren en Sequential-blok, der tilgås via model.classifier, ikke model.fc. Kontrollér altid modelarkitekturen for at finde det korrekte attributnavn.

EfficientNet-B0's klassifikator forventer inputfunktioner med 1280 dimensioner. Når du skriver kode, der fungerer med flere arkitekturer, kan du undersøge det endelige lag med in_features i stedet for at fastlåse dimensionen, så koden bliver mere genanvendelig på tværs af forskellige valg af grundnetværk.

I ViT tilgås klassifikationshovedet via model.heads. Funktionsdimensionen fra ViT-B/16's grundnetværk er 768 (transformerens indlejringsdimension). Når du har fastfrosset alle parametre, skal du erstatte model.heads med et nyt nn.Linear(768, num_classes).

ViT har mindre fordel af funktionsudtrækning end CNN'er, fordi dets opmærksomhedslag er mere opgavespecifikke — de lærer at rette opmærksomheden mod andre billedområder end dem, din opgave kræver. Hvis du bruger et ViT-grundnetværk, bør du som minimum frigive de sidste få transformer-koderblokke for at opnå den bedste ydeevne. Til et hurtigt eksperiment er fuld funktionsudtrækning dog stadig et gyldigt udgangspunkt.

Efter træning med fastfrosne funktioner skal du evaluere på valideringssættet ved hjælp af standardmetrikker for klassifikation. En velindstillet funktionsudtrækker opnår ofte over 90 % nøjagtighed på små tilpassede datasæt (500-5000 billeder pr. klasse), hvor træning fra bunden ville føre til fuldstændig overtilpasning.

Hvis nøjagtigheden er lavere end forventet, kan du overveje: (1) at tilføje dataforøgelse under træningen, (2) at bruge et dropout-lag før det lineære hoved, (3) at bruge et lidt mere udtryksfuldt hoved (to lineære lag med ReLU) eller (4) at gå over til delvis finjustering ved at frigive det sidste residualblok. Overvåg både trænings- og valideringsnøjagtigheden for at skelne mellem overtilpasning og undertilpasning.

Funktionsudtrækning fungerer bedst, når kildedomænet (ImageNet: naturlige fotografier) og måldomænet ligner hinanden. Når dine data er meget anderledes — røntgenbilleder, satellitbilleder, mikroskopi eller infrarøde termiske billeder — overføres funktioner på lavt niveau stadig (kantdetektorer er universelle), men ImageNets funktioner på højere niveau er måske mindre nyttige.

Tegn på, at funktionsudtrækningen klarer sig dårligt: Valideringsnøjagtigheden flader ud langt under forventningen, eller træningsnøjagtigheden er meget højere end valideringsnøjagtigheden (hvilket viser, at hovedet overtilpasser for få funktioner). I disse tilfælde skal du gå over til finjustering: frigiv nogle lag i grundnetværket, og træn med en meget lavere indlæringshastighed for gradvist at tilpasse de forudlærte funktioner til dit domæne.

I denne lektion har du lært, at funktionsudtrækning fastfryser alle parametre i grundnetværket og kun træner et nyt klassifikationshoved, hvilket giver hurtig træning og gode resultater, når dine data ligner ImageNet; at fastfrysning udføres ved at indstille requires_grad=False på parametrene i grundnetværket, før det endelige lag udskiftes; og at offline-udtrækning af funktioner på forhånd går endnu hurtigere ved at køre grundnetværket én gang og gemme funktionsvektorerne. Næste gang lærer du om finjustering — hvordan du forsigtigt frigiver lag i grundnetværket med lave indlæringshastigheder for at opnå endnu bedre nøjagtighed.