logo

TechCodeview

VGG-16 | CNN-modell

En Convolutional Neural Network (CNN)-arkitektur er en dyp læringsmodell designet for å behandle strukturerte rutenettlignende data, for eksempel bilder. Den består av flere lag, inkludert konvolusjonslag, sammenslåing og fullstendig sammenkoblede lag. CNN-er er svært effektive for oppgaver som bildeklassifisering, objektgjenkjenning og bildesegmentering på grunn av deres hierarkiske funksjonsekstraksjonsmuligheter.

VGG-16

VGG-16-modellen er en konvolusjonelt nevralt nettverk (CNN) arkitektur som ble foreslått av Visual Geometry Group (VGG) ved University of Oxford. Den er preget av sin dybde, bestående av 16 lag, inkludert 13 konvolusjonslag og 3 fullt sammenkoblede lag. VGG-16 er kjent for sin enkelhet og effektivitet, samt sin evne til å oppnå sterk ytelse på ulike datasynoppgaver, inkludert bildeklassifisering og objektgjenkjenning. Modellens arkitektur har en stabel med konvolusjonslag etterfulgt av maks-pooling-lag, med gradvis økende dybde. Denne designen gjør det mulig for modellen å lære intrikate hierarkiske representasjoner av visuelle funksjoner, noe som fører til robuste og nøyaktige spådommer. Til tross for sin enkelhet sammenlignet med nyere arkitekturer, er VGG-16 fortsatt et populært valg for mange dyplæringsapplikasjoner på grunn av sin allsidighet og utmerkede ytelse.



ImageNet Large Scale Visual Recognition Challenge (ILSVRC) er en årlig konkurranse innen datasyn hvor team takler oppgaver inkludert objektlokalisering og bildeklassifisering. VGG16, foreslått av Karen Simonyan og Andrew Zisserman i 2014, oppnådde topprangeringer i begge oppgavene, ved å oppdage objekter fra 200 klasser og klassifisere bilder i 1000 kategorier.


css opasitet overgang

VGG-16 arkitektur



Denne modellen oppnår 92,7 % topp-5 test nøyaktigheten på ImageNet-datasettet som inneholder 14 millioner bilder som tilhører 1000 klasser.

VGG-16 modellmål:

ImageNet-datasettet inneholder bilder med fast størrelse på 224*224 og har RGB-kanaler. Så vi har en tensor av (224, 224, 3) som vårt innspill. Denne modellen behandler inngangsbildet og sender ut a-vektoren av 1000 verdier:

hat{y} =egin{bmatrix} hat{y_0} hat{y_1} hat{y_2} . . . hat{y}_{999} end{bmatrix}



Denne vektoren representerer klassifiseringssannsynligheten for den tilsvarende klassen. Anta at vi har en modell som forutsier at bildet med sannsynlighet tilhører klasse 0 1 , klasse 1 med sannsynlighet 0,05 , klasse 2 med sannsynlighet 0,05 , klasse 3 med sannsynlighet 0,03 , klasse 780 med sannsynlighet 0,72 , klasse 999 med sannsynlighet 0,05 og alle andre klasse med 0 .

så klassifiseringsvektoren for dette vil være:

hat{y}=egin{bmatrix} hat{y_{0}}=0.1 0.05 0.05 0.03 . . . hat{y_{780}} = 0.72 . . hat{y_{999}} = 0.05 end{bmatrix}

For å sikre at disse sannsynlighetene øker 1 , bruker vi softmax-funksjonen.

Denne softmax-funksjonen er definert som følger:

hat{y}_i = frac{e^{z_i}}{sum_{j=1}^{n} e^{z_j}}

java opplæring

Etter dette tar vi de 5 mest sannsynlige kandidatene inn i vektoren.

C =egin{bmatrix} 780 0 1 2 999 end{bmatrix}

og vår grunnsannhetsvektor er definert som følger:

G = egin{bmatrix} G_{0} G_{1} G_{2} end{bmatrix}=egin{bmatrix} 780 2 999 end{bmatrix}

Deretter definerer vi feilfunksjonen vår som følger:

E = frac{1}{n}sum_{k}min_{i}d(c_{i}, G_{k})

streng til int i java

Den beregner minimumsavstanden mellom hver grunnsannhetsklasse og de predikerte kandidatene, der avstandsfunksjonen d er definert som:

  • d=0 hvisc_i=G_k
  • d=1 ellers

Så tapsfunksjonen for dette eksemplet er:

egin{aligned} E &=frac{1}{3}left ( min_{i}d(c_{i}, G_{1}) +min_{i}d(c_{i}, G_{2})+min_{i}d(c_{i}, G_{3}) ight ) &= frac{1}{3}(0 + 0 +0) &=0 end{aligned}

Siden alle kategoriene i grunnsannheten er i den spådde topp-5-matrisen, så tapet blir 0.

VGG Arkitektur:

VGG-16-arkitekturen er et dypt konvolusjonelt nevralt nettverk (CNN) designet for bildeklassifiseringsoppgaver. Den ble introdusert av Visual Geometry Group ved University of Oxford. VGG-16 er preget av sin enkelhet og ensartede arkitektur, noe som gjør det enkelt å forstå og implementere.

binær søkepython

VGG-16-konfigurasjonen består vanligvis av 16 lag, inkludert 13 konvolusjonslag og 3 fullt sammenkoblede lag. Disse lagene er organisert i blokker, der hver blokk inneholder flere konvolusjonslag etterfulgt av et maks-pooling-lag for nedsampling.

VGG-16 arkitekturkart

Her er en oversikt over VGG-16-arkitekturen basert på de angitte detaljene:

  1. Inndatalag:
    1. Inndatadimensjoner: (224, 224, 3)
  2. Konvolusjonslag (64 filtre, 3×3 filtre, samme polstring):
    • To påfølgende konvolusjonslag med 64 filtre hver og en filterstørrelse på 3×3.
    • Samme polstring brukes for å opprettholde romlige dimensjoner.
  3. Maks pooling-lag (2×2, skritt 2):
    • Maks-pooling lag med en bassengstørrelse på 2×2 og et skritt på 2.
  4. Konvolusjonslag (128 filtre, 3×3 filtre, samme polstring):
    • To påfølgende konvolusjonslag med 128 filtre hver og en filterstørrelse på 3×3.
  5. Maks pooling-lag (2×2, skritt 2):
    • Maks-pooling lag med en bassengstørrelse på 2×2 og et skritt på 2.
  6. Konvolusjonslag (256 filtre, 3×3 filtre, samme polstring):
    • To påfølgende konvolusjonslag med 256 filtre hver og en filterstørrelse på 3×3.
  7. Konvolusjonslag (512 filtre, 3×3 filtre, samme polstring):
    • To sett med tre påfølgende konvolusjonslag med 512 filtre hver og en filterstørrelse på 3×3.
  8. Maks pooling-lag (2×2, skritt 2):
    • Maks-pooling lag med en bassengstørrelse på 2×2 og et skritt på 2.
  9. Stabel med konvolusjonslag og maksimal pooling:
    • To ekstra konvolusjonslag etter forrige stabel.
    • Filterstørrelse: 3×3.
  10. Utflating:
    • Flat ut funksjonskartet (7x7x512) til en vektor med størrelse 25088.
  11. Fullt tilkoblede lag:
    • Tre fullt tilkoblede lag med ReLU-aktivering.
    • Første lag med inngangsstørrelse 25088 og utgangsstørrelse 4096.
    • Andre lag med inngangsstørrelse 4096 og utgangsstørrelse 4096.
    • Tredje lag med inngangsstørrelse 4096 og utgangsstørrelse 1000, tilsvarende de 1000 klassene i ILSVRC-utfordringen.
    • Softmax-aktivering brukes på utgangen til det tredje fullt tilkoblede laget for klassifisering.

Denne arkitekturen følger spesifikasjonene som er gitt, inkludert bruk av ReLU-aktiveringsfunksjonen og det endelige fullt tilkoblede lagets utgangssannsynligheter for 1000 klasser ved bruk av softmax-aktivering.

VGG-16-konfigurasjon:

Hovedforskjellen mellom VGG-16 konfigurasjoner C og D ligger i bruken av filterstørrelser i noen av konvolusjonslagene. Mens begge versjonene hovedsakelig bruker 3×3-filtre, er det i versjon D tilfeller der 1×1-filtre brukes i stedet. Denne lille variasjonen resulterer i en forskjell i antall parametere, der versjon D har et litt høyere antall parametere sammenlignet med versjon C. Begge versjonene opprettholder imidlertid den overordnede arkitekturen og prinsippene til VGG-16-modellen.

Ulik VGG-konfigurasjon

Objektlokalisering i bilde:

For å utføre lokalisering må vi erstatte klassepoengsummen med plasseringskoordinater for avgrensende bokser. En grenseboksplassering er representert av 4D-vektoren (senterkoordinater(x,y), høyde, bredde). Det er to versjoner av lokaliseringsarkitektur, den ene er avgrensende boks deles mellom forskjellige kandidater (utgangen er 4 parameter vektor) og den andre er en grenseboks er klassespesifikk (utgangen er 4000 parametervektor). Oppgaven eksperimenterte med begge tilnærmingene på VGG -16 (D) arkitektur. Her må vi også endre tap fra klassifiseringstap til regresjonstapsfunksjoner (som f.eks MSE ) som straffer avviket til forventet tap fra grunnsannheten.

Resultater: VGG-16 var en av de best presterende arkitekturene i ILSVRC-utfordringen 2014. Den ble nummer to i klassifiseringsoppgaven med en topp-5 klassifiseringsfeil på 7,32 % (bare bak GoogLeNet med en klassifiseringsfeil på 6,66 % ). Det ble også vinneren av lokaliseringsoppgave med 25,32 % lokaliseringsfeil.

Begrensninger for VGG 16:

  • Den er veldig treg å trene (den originale VGG-modellen ble trent på Nvidia Titan GPU i 2-3 uker).
  • Størrelsen på VGG-16-trente imageNet-vekter er 528 MB. Så det tar ganske mye diskplass og båndbredde som gjør det ineffektivt.
  • 138 millioner parametere fører til eksploderende gradientproblem.

Ytterligere fremskritt: Resnett er introdusert for å forhindre eksploderende gradientproblem som oppsto i VGG-16.