Konvolusjonsnevrale nettverk (CNN-er) er mye brukt innen bildeklassifisering på grunn av deres evne til å trekke ut hierarkiske trekk. I denne oppgaven skal du implementere og trene et VGG-lignende CNN ved hjelp av TensorFlow og Keras på CIFAR-10-datasettet. Datasettet består av 60 000 bilder (32×32×3) fordelt på 10 ulike klasser, inkludert fly, biler, fugler, katter og flere.

Dette prosjektet vil veilede deg gjennom lasting av datasettet, forhåndsprosessering av bildene, definering av CNN-modellen, trening og evaluering av ytelsen.

1. Forhåndsprosessering av data for CNN-er

Før du trener et CNN, er forhåndsprosessering av data et avgjørende steg for å sikre bedre ytelse og raskere konvergens. Vanlige forhåndsprosesseringsteknikker inkluderer:

• Normalisering: denne metoden innebærer å skalere pikselverdiene i bildene fra et område mellom 0 og 255 til et område mellom 0 og 1. Dette implementeres ofte som x_train / 255.0, x_test / 255.0;

• One-hot-koding: etiketter konverteres ofte til one-hot-kodede vektorer for klassifiseringsoppgaver. Dette gjøres vanligvis med funksjonen keras.utils.to_categorical, som omgjør heltallsetiketter (f.eks. 0, 1, 2, osv.) til en one-hot-kodet vektor, som [1, 0, 0, 0] for et klassifiseringsproblem med 4 klasser.

2. Bygging av CNN-arkitektur

En CNN-arkitektur består av flere lag som utfører ulike oppgaver for å trekke ut trekk og gjøre prediksjoner. Du kan implementere sentrale CNN-lag ved å bruke:

Konvolusjonslag (Conv2D)

Merk

input_shape-parameteren må kun spesifiseres i inndatalaget.

Pooling-lag (MaxPooling2D)

Flate lag

Tett lag

Merk

Det siste tette laget har vanligvis et antall enheter lik antall klasser og bruker en softmax-aktiveringsfunksjon for å gi en sannsynlighetsfordeling over klassene.

3. Modellkompilering

Etter at arkitekturen er definert, må modellen kompileres. Dette steget innebærer å spesifisere tapsfunksjon, optimaliserer og metrikker som skal styre modellen under trening. Følgende metoder brukes ofte i CNN-er:

Optimaliserer (Adam)

Optimalisereren justerer vektene i modellen for å minimere tapsfunksjonen. Adam-optimalisereren er populær på grunn av sin effektivitet og evne til å tilpasse læringsraten under trening.

Tapingsfunksjon (Kategorisk krysstap)

For flerkategoriklassifisering brukes vanligvis kategorisk krysstap som tapingsfunksjon. Dette kan implementeres slik:

Metrikker

Modellens ytelse overvåkes ved hjelp av metrikker for klassifiseringsoppgaver, som nøyaktighet, presisjon, tilbakekalling osv. Disse kan defineres som:

Kompilering

4. Trening av modellen

Trening av et CNN innebærer å mate nettverket med inndata, beregne tapet og oppdatere vektene ved hjelp av backpropagation. Treningsprosessen styres av følgende sentrale metoder:

• Tilpasning av modellen: fit()-metoden brukes for å trene modellen. Denne metoden tar inn treningsdata, antall epoker og batch-størrelse. Den inkluderer også en valgfri valideringssplit for å evaluere modellens ytelse på ukjente data under treningen:

• Batch-størrelse og epoker: Batch-størrelsen bestemmer antall eksempler som behandles før modellens vekter oppdateres, og antall epoker refererer til hvor mange ganger hele datasettet føres gjennom modellen.

5. Evaluering

Klassifikasjonsrapport

sklearn.metrics.classification_report() sammenligner sanne og predikerte verdier fra testdatasettet. Den inkluderer presisjon, recall og F1-score for hver klasse. Men metodene må kun motta klasseetiketter, så husk å konvertere tilbake fra vektorer ([0,0,1,0] -> 2):

Evaluer

Når modellen er trent, evalueres den på testdatasettet for å vurdere dens generaliseringsevne. Evalueringen gir metrikker, som ble nevnt i .compile()-metoden. Evalueringen utføres ved hjelp av .evaluate():

Forvirringsmatrise

For å få bedre innsikt i modellens ytelse, kan vi visualisere forvirringsmatrisen, som viser sanne positive, falske positive, sanne negative og falske negative prediksjoner for hver klasse. Forvirringsmatrisen kan beregnes ved hjelp av TensorFlow:

Denne matrisen kan deretter visualiseres ved hjelp av varmekart for å observere hvor godt modellen presterer på hver klasse:

1. Last inn og forbehandle datasettet

• Importer CIFAR-10-datasettet fra Keras;

• Normaliser pikselverdiene til området [0,1] for bedre konvergens;

• Konverter klasselabelene til one-hot encoded format for kategorisk klassifisering.

2. Definer CNN-modellen

Implementer en VGG-lignende CNN-arkitektur med følgende nøkkellag:

Konvolusjonslag:

• Kernelstørrelse: 3×3;

• Aktiveringsfunksjon: ReLU;

• Padding: 'same'.

Pooling-lag:

• Pooling-type: max pooling;

• Pooling-størrelse: 2×2.

Dropout-lag (Forhindrer overtilpasning ved å tilfeldig deaktivere nevroner):

• Dropout-rate: 25%.

Flatten-lag – konverterer 2D feature maps til en 1D-vektor for klassifisering.

Fullt tilkoblede lag – tette lag for endelig klassifisering, med en relu- eller softmax-utgangslag.

Kompiler modellen med:

• Adam optimizer (for effektiv læring);

• Categorical cross-entropy tapsfunksjon (for multiklasseklassifisering);

• Accuracy metric for å måle ytelse (klassene er balanserte, og du kan legge til andre metrikker selv).

3. Tren modellen

• Spesifiser epochs og batch_size parametere for trening (f.eks. epochs=20, batch_size=64);

• Spesifiser validation_split parameter for å angi prosentandel av treningsdata som blir valideringsdata for å spore modellens ytelse på ukjente bilder;

• Lagre treningshistorikken for å visualisere nøyaktighets- og tapstrender.

4. Evaluer og visualiser resultater

• Test modellen på CIFAR-10 testdata og skriv ut nøyaktigheten;

• Plott trenings-tap vs. validerings-tap for å sjekke for overtilpasning;

• Plott trenings-nøyaktighet vs. validerings-nøyaktighet for å sikre læringsprogresjon.

COLAB CNN-PROSJEKT