Convolutional neural networks (CNN'er) anvendes bredt til billedklassificering på grund af deres evne til at udtrække hierarkiske træk. I denne opgave skal du implementere og træne en VGG-lignende CNN ved hjælp af TensorFlow og Keras på CIFAR-10 datasættet. Datasættet består af 60.000 billeder (32×32×3), der tilhører 10 forskellige klasser, herunder fly, biler, fugle, katte og flere.

Dette projekt guider dig igennem indlæsning af datasættet, forbehandling af billederne, definition af CNN-modellen, træning af modellen og evaluering af dens ydeevne.

1. Dataforbehandling til CNN'er

Før træning af en CNN er forbehandling af data et afgørende trin for at sikre bedre ydeevne og hurtigere konvergens. Almindelige forbehandlingsmetoder omfatter:

• Normalisering: denne metode indebærer skalering af billeders pixelværdier fra et interval mellem 0 og 255 til et interval mellem 0 og 1. Det implementeres ofte som x_train / 255.0, x_test / 255.0;

• One-hot encoding: etiketter konverteres ofte til one-hot kodede vektorer til klassifikationsopgaver. Dette udføres typisk med funktionen keras.utils.to_categorical, som omdanner heltalsetiketter (f.eks. 0, 1, 2, osv.) til en one-hot kodet vektor, såsom [1, 0, 0, 0] for et 4-klasses klassifikationsproblem.

2. Opbygning af CNN-arkitektur

En CNN-arkitektur består af flere lag, der udfører forskellige opgaver for at udtrække træk og foretage forudsigelser. Du kan implementere centrale CNN-lag ved at:

Konvolutionelt lag (Conv2D)

Bemærk

input_shape-parameteren skal kun angives i inputlaget.

Pooling-lag (MaxPooling2D)

Fladgøringslag

Tæt lag

Bemærk

Det sidste tætte lag har typisk et antal enheder svarende til antallet af klasser og anvender en softmax aktiveringsfunktion for at give en sandsynlighedsfordeling på tværs af klasserne.

3. Modellens kompilering

Efter arkitekturen er defineret, skal modellen kompileres. Dette trin indebærer at specificere tabsfunktion, optimeringsalgoritme og metrikker, som guider modellen under træning. Følgende metoder anvendes ofte i CNN'er:

Optimeringsalgoritme (Adam)

Optimeringsalgoritmen justerer modellens vægte for at minimere tabsfunktionen. Adam-optimeringsalgoritmen er populær på grund af dens effektivitet og evne til at tilpasse indlæringsraten under træning.

Tab af funktion (Kategorisk krydsentropi)

Til multi-klasse klassifikation anvendes kategorisk krydsentropi typisk som tab af funktion. Dette kan implementeres som:

Metrikker

Modelpræstation overvåges ved hjælp af metrikker for klassifikationsopgaver, såsom nøjagtighed, præcision, recall osv. Disse kan defineres som:

Kompilér

4. Træning af modellen

Træning af et CNN indebærer at give inputdata til netværket, beregne tabet og opdatere vægtene ved hjælp af backpropagation. Træningsprocessen styres af følgende nøglemetoder:

• Tilpasning af modellen: fit()-metoden anvendes til at træne modellen. Denne metode modtager træningsdata, antal epoker og batch-størrelse. Den inkluderer også en valgfri valideringssplit for at evaluere modellens ydeevne på usete data under træningen:

• Batch-størrelse og epoker: Batch-størrelsen bestemmer antallet af eksempler, der behandles, før modelvægtene opdateres, og antallet af epoker angiver hvor mange gange hele datasættet føres gennem modellen.

5. Evaluering

Klassifikationsrapport

sklearn.metrics.classification_report() sammenligner sande og forudsagte værdier fra testdatasættet. Den indeholder præcision, recall og F1-score for hver klasse. Metoderne kræver dog kun klasselabels, så husk at konvertere dem tilbage fra vektorer ([0,0,1,0] -> 2):

Evaluering

Når modellen er trænet, evalueres den på testdatasættet for at vurdere dens generaliseringsevne. Evalueringen giver metrikker, som blev nævnt i .compile()-metoden. Evalueringen udføres ved hjælp af .evaluate():

Forvirringsmatrix

For at få yderligere indsigt i modellens ydeevne kan vi visualisere forvirringsmatrixen, som viser de sande positive, falske positive, sande negative og falske negative forudsigelser for hver klasse. Forvirringsmatrixen kan beregnes ved hjælp af TensorFlow:

Denne matrix kan derefter visualiseres ved hjælp af heatmaps for at observere, hvor godt modellen præsterer på hver klasse:

1. Indlæs og forbehandl datasættet

• Importér CIFAR-10 datasættet fra Keras;

• Normalisér pixelværdierne til intervallet [0,1] for bedre konvergens;

• Konvertér klasselabels til one-hot encoded format til kategorisk klassifikation.

2. Definér CNN-modellen

Implementér en VGG-lignende CNN-arkitektur med følgende nøglelag:

Konvolutionslag:

• Kernelstørrelse: 3×3;

• Aktiveringsfunktion: ReLU;

• Padding: 'same'.

Poolinglag:

• Poolingtype: max pooling;

• Poolingstørrelse: 2×2.

Dropout-lag (Forebyg overfitting ved tilfældigt at deaktivere neuroner):

• Dropout-rate: 25%.

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

Fuldt forbundne lag – tætte lag til endelig klassifikation, med et relu- eller softmax-outputlag.

Kompilér modellen med:

• Adam optimizer (for effektiv læring);

• Categorical cross-entropy tab-funktion (til multi-klasse klassifikation);

• Accuracy metric til at måle præstation (klasser er balancerede, og du kan tilføje andre metrikker efter behov).

3. Træn modellen

• Angiv parametrene epochs og batch_size til træning (f.eks. epochs=20, batch_size=64);

• Angiv parameteren validation_split for at definere procentdelen af træningsdata, der bliver valideringsdata for at følge modellens præstation på usete billeder;

• Gem træningshistorikken for at visualisere tendenser i nøjagtighed og tab.

4. Evaluer og visualisér resultater

• Test modellen på CIFAR-10 testdata og udskriv nøjagtigheden;

• Plot træningstab vs. valideringstab for at kontrollere overfitting;

• Plot træningsnøjagtighed vs. valideringsnøjagtighed for at sikre læringsprogression.

COLAB CNN PROJEKT