logo

TechCodeview

VGG-16 | CNN model

A Convolutional Neural Network (CNN) arkitektur er en dyb læringsmodel designet til at behandle strukturerede gitterlignende data, såsom billeder. Den består af flere lag, inklusive foldning, pooling og fuldt forbundne lag. CNN'er er yderst effektive til opgaver som billedklassificering, objektdetektering og billedsegmentering på grund af deres hierarkiske funktionsudtrækningsmuligheder.

VGG-16

VGG-16-modellen er en konvolutionelt neuralt netværk (CNN) arkitektur, der blev foreslået af Visual Geometry Group (VGG) ved University of Oxford. Den er kendetegnet ved sin dybde, der består af 16 lag, herunder 13 foldede lag og 3 fuldt forbundne lag. VGG-16 er kendt for sin enkelhed og effektivitet, såvel som dens evne til at opnå stærk ydeevne på forskellige computervisionsopgaver, herunder billedklassificering og objektgenkendelse. Modellens arkitektur har en stak af foldede lag efterfulgt af max-pooling-lag med gradvist stigende dybde. Dette design gør det muligt for modellen at lære indviklede hierarkiske repræsentationer af visuelle funktioner, hvilket fører til robuste og nøjagtige forudsigelser. På trods af sin enkelhed sammenlignet med nyere arkitekturer er VGG-16 stadig et populært valg til mange deep learning-applikationer på grund af dens alsidighed og fremragende ydeevne.



ImageNet Large Scale Visual Recognition Challenge (ILSVRC) er en årlig konkurrence i computervision, hvor teams tackler opgaver, herunder objektlokalisering og billedklassificering. VGG16, foreslået af Karen Simonyan og Andrew Zisserman i 2014, opnåede topplaceringer i begge opgaver, idet de opdagede objekter fra 200 klasser og klassificerede billeder i 1000 kategorier.


kali linux terminal

VGG-16 arkitektur



Denne model opnår 92,7 % top-5 test nøjagtighed på ImageNet-datasættet, som indeholder 14 millioner billeder tilhørende 1000 klasser.

VGG-16 modelmål:

ImageNet-datasættet indeholder billeder af fast størrelse på 224*224 og har RGB-kanaler. Så vi har en tensor af (224, 224, 3) som vores input. Denne model behandler inputbilledet og udsender en vektor af 1000 værdier:

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



Denne vektor repræsenterer klassificeringssandsynligheden for den tilsvarende klasse. Antag, at vi har en model, der forudsiger, at billedet med sandsynlighed tilhører klasse 0 1 , klasse 1 med sandsynlighed 0,05 , klasse 2 med sandsynlighed 0,05 , klasse 3 med sandsynlighed 0,03 , klasse 780 med sandsynlighed 0,72 , klasse 999 med sandsynlighed 0,05 og alle andre klasse med 0 .

så klassifikationsvektoren 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 at sikre, at disse sandsynligheder øges 1 , vi bruger softmax-funktionen.

Denne softmax-funktion er defineret som følger:

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

java tutorial

Herefter tager vi de 5 mest sandsynlige kandidater ind i vektoren.

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

og vores grundsandhedsvektor er defineret som følger:

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

Derefter definerer vi vores fejlfunktion som følger:

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

blokere YouTube-annoncer for Android

Den beregner minimumsafstanden mellem hver jordsandhedsklasse og de forudsagte kandidater, hvor afstandsfunktionen d er defineret som:

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

Så tabsfunktionen for dette eksempel 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}

Da alle kategorierne i jordsandhed er i den forudsagte top-5 matrix, så tabet bliver 0.

VGG Arkitektur:

VGG-16-arkitekturen er et deep convolutional neural network (CNN) designet til billedklassificeringsopgaver. Det blev introduceret af Visual Geometry Group ved University of Oxford. VGG-16 er kendetegnet ved sin enkelhed og ensartede arkitektur, hvilket gør det nemt at forstå og implementere.

binær søgepython

VGG-16-konfigurationen består typisk af 16 lag, herunder 13 foldede lag og 3 fuldt forbundne lag. Disse lag er organiseret i blokke, hvor hver blok indeholder flere foldningslag efterfulgt af et max-pooling-lag til nedsampling.

VGG-16 arkitektur kort

Her er en oversigt over VGG-16-arkitekturen baseret på de angivne detaljer:

  1. Input lag:
    1. Inputdimensioner: (224, 224, 3)
  2. Konvolutionelle lag (64 filtre, 3×3 filtre, samme polstring):
    • To på hinanden følgende foldningslag med hver 64 filtre og en filterstørrelse på 3×3.
    • Samme polstring anvendes for at opretholde rumlige dimensioner.
  3. Max pooling lag (2×2, skridt 2):
    • Max-pooling-lag med en poolstørrelse på 2×2 og et skridt på 2.
  4. Konvolutionelle lag (128 filtre, 3×3 filtre, samme polstring):
    • To på hinanden følgende foldede lag med 128 filtre hver og en filterstørrelse på 3×3.
  5. Max pooling lag (2×2, skridt 2):
    • Max-pooling-lag med en poolstørrelse på 2×2 og et skridt på 2.
  6. Konvolutionelle lag (256 filtre, 3×3 filtre, samme polstring):
    • To på hinanden følgende foldede lag med 256 filtre hver og en filterstørrelse på 3×3.
  7. Konvolutionelle lag (512 filtre, 3×3 filtre, samme polstring):
    • To sæt af tre på hinanden følgende foldningslag med 512 filtre hver og en filterstørrelse på 3×3.
  8. Max pooling lag (2×2, skridt 2):
    • Max-pooling-lag med en poolstørrelse på 2×2 og et skridt på 2.
  9. Stack of Convolutional Layers og Max Pooling:
    • To yderligere foldningslag efter den forrige stak.
    • Filterstørrelse: 3×3.
  10. Udfladning:
    • Flad output-funktionskortet (7x7x512) ud til en vektor med størrelsen 25088.
  11. Fuldt forbundne lag:
    • Tre fuldt forbundne lag med ReLU-aktivering.
    • Første lag med inputstørrelse 25088 og outputstørrelse 4096.
    • Andet lag med inputstørrelse 4096 og outputstørrelse 4096.
    • Tredje lag med inputstørrelse 4096 og outputstørrelse 1000, svarende til de 1000 klasser i ILSVRC-udfordringen.
    • Softmax-aktivering påføres udgangen af ​​det tredje fuldt tilsluttede lag til klassificering.

Denne arkitektur følger de angivne specifikationer, herunder brugen af ​​ReLU-aktiveringsfunktionen og det endelige fuldt forbundne lag-outputsandsynlighed for 1000 klasser ved hjælp af softmax-aktivering.

VGG-16-konfiguration:

Hovedforskellen mellem VGG-16 konfigurationer C og D ligger i brugen af ​​filterstørrelser i nogle af foldningslagene. Mens begge versioner overvejende bruger 3×3-filtre, er der i version D tilfælde, hvor 1×1-filtre bruges i stedet. Denne lille variation resulterer i en forskel i antallet af parametre, hvor version D har et lidt højere antal parametre sammenlignet med version C. Begge versioner bevarer dog VGG-16 modellens overordnede arkitektur og principper.

Forskellig VGG-konfiguration

Objektlokalisering i billede:

For at udføre lokalisering er vi nødt til at erstatte klassens score med afgrænsningsboksplaceringskoordinater. En afgrænsningsboksplacering er repræsenteret af 4-D vektoren (centerkoordinater(x,y), højde, bredde). Der er to versioner af lokaliseringsarkitektur, den ene er afgrænsningsboksen deles mellem forskellige kandidater (outputtet er 4 parameter vektor), og den anden er en afgrænsningsboks er klassespecifik (outputtet er 4000 parameter vektor). Papiret eksperimenterede med begge tilgange til VGG -16 (D) arkitektur. Her skal vi også ændre tab fra klassifikationstab til regressionstabsfunktioner (såsom MSE ), der straffer afvigelsen af ​​forudsagt tab fra grundsandheden.

Resultater: VGG-16 var en af ​​de bedst ydende arkitekturer i ILSVRC-udfordringen 2014. Den var nummer to i klassifikationsopgaven med en top-5 klassifikationsfejl på 7,32 % (kun bag GoogLeNet med en klassifikationsfejl på 6,66 % ). Det var også vinderen af ​​lokaliseringsopgave med 25,32 % lokaliseringsfejl.

Begrænsninger af VGG 16:

  • Den er meget langsom at træne (den originale VGG-model blev trænet på Nvidia Titan GPU i 2-3 uger).
  • Størrelsen på VGG-16 trænede imageNet vægte er 528 MB. Så det tager ret meget diskplads og båndbredde, hvilket gør det ineffektivt.
  • 138 millioner parametre fører til eksploderende gradientproblem.

Yderligere fremskridt: Resnets introduceres for at forhindre eksploderende gradientproblem, der opstod i VGG-16.