Utfordring: Bygge et CNN

Konvolusjonelle nevrale nettverk (CNN-er) brukes mye innen bildeklassifisering på grunn av deres evne til å trekke ut hierarkiske trekk. I denne oppgaven skal du implementere og trene en 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 veileder deg gjennom lasting av datasettet, forhåndsprosessering av bildene, definering av CNN-modellen, trening og evaluering av ytelsen.

1. Dataprosessering for CNN-er

Før man 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 4-klasses klassifiseringsproblem.

2. Bygging av CNN-arkitektur

En CNN-arkitektur består av flere lag som utfører ulike oppgaver for å trekke ut egenskaper og gjøre prediksjoner. Nøkkellag i en CNN kan implementeres ved å bruke:

Konvolusjonslag (Conv2D)

keras.layers.Conv2D(filters, kernel_size, activation='relu', padding='same', input_shape=(height, width, channels))

Pooling-lag (MaxPooling2D)

keras.layers.MaxPooling2D(pool_size=(2, 2))

Flatten-lag

keras.layers.Flatten()

Dense-lag

layers.Dense(units=512, activation='relu')
layers.Dense(10, activation='softmax')

3. Modellkompilering

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

Optimaliseringsalgoritme (Adam)

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

keras.optimizers.Adam()

Tapsfunksjon (Categorical Crossentropy)

For multiklasseklassifisering brukes vanligvis categorical crossentropy som tapsfunksjon. Dette kan implementeres slik:

keras.losses.CategoricalCrossentropy()

Metrikker

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

metrics = [
    keras.metrics.Accuracy(), 
    keras.metrics.Precision(), 
    keras.metrics.Recall()
]

Kompilering

model.compile(optimizer='adam', 
              loss='categorical_crossentropy', # Or keras.losses.CategoricalCrossentropy()
              metrics=metrics)

4. Trening av modellen

Trening av et CNN innebærer å mate nettverket med inndata, beregne tapet og oppdatere vektene ved hjelp av tilbakepropagering. 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:

history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)

• 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

Klassifiseringsrapport

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

y_pred = model.predict(x_test)
y_pred_classes = np.argmax(y_pred,axis = 1)
y_test_classes = np.argmax(y_test, axis = 1)

report = classification_report(y_test_classes, y_pred_classes, target_names=class_names)
print(report)

Evaluering

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 med .evaluate():

results = model.evaluate(x_test, y_test, verbose=2, return_dict=True)

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 med TensorFlow:

confusion_mtx = tf.math.confusion_matrix(y_test_classes, y_pred_classes)

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

plt.figure(figsize=(12, 9))
c = sns.heatmap(confusion_mtx, annot=True, fmt='g')
c.set(xticklabels=class_names, yticklabels=class_names)

plt.show()

1. Last inn og forhåndsprosesser 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-funksjonskart til en 1D-vektor for klassifisering.

Fullt tilkoblede lag – tette lag for endelig klassifisering, med et 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