Convolutional neurale netværk (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 et 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 gennem 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 et 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 kodning: 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 funktioner og lave forudsigelser. Centrale CNN-lag kan implementeres ved hjælp af:

Konvolutionslag (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))

Fladgøringslag

keras.layers.Flatten()

Tæt lag

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

3. Modelkompilering

Efter arkitekturen er defineret, skal modellen kompileres. Dette trin indebærer at specificere tab-funktionen, optimeringsalgoritmen og metrikker, som vil styre modellen under træningen. Følgende metoder anvendes ofte i CNN'er:

Optimeringsalgoritme (Adam)

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

keras.optimizers.Adam()

Tab-funktion (Categorical Crossentropy)

Til multi-klasse klassifikation anvendes typisk categorical crossentropy som tab-funktion. Dette kan implementeres som:

keras.losses.CategoricalCrossentropy()

Metrikker

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

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

Kompilér

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

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 centrale metoder:

• Tilpasning af modellen: fit()-metoden bruges til at træne modellen. Denne metode tager 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:

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 antallet af eksempler, der behandles, før modelvægtene opdateres, og antallet af epoker refererer til 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 inkluderer præcision, recall og F1-score for hver klasse. Metoderne kræver kun klasselabels, så husk at konvertere dem tilbage 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 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 med .evaluate():

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

Konfusionsmatrix

For at få yderligere indsigt i modellens ydeevne kan vi visualisere konfusionsmatrixen, som viser de sande positive, falske positive, sande negative og falske negative forudsigelser for hver klasse. Konfusionsmatrixen kan beregnes med TensorFlow:

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

Denne matrix kan derefter visualiseres ved hjælp af heatmaps for at observere, hvor godt modellen præsterer 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. 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 (klasserne er balancerede, og du kan tilføje andre metrics efter behov).

3. Træn modellen

• Angiv parametrene epochs og batch_size for 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