Utfordring: Bygge et CNN
Konvolusjonsnevrale 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 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 veileder deg gjennom lasting av datasettet, bildebehandling, definering av CNN-modellen, trening og evaluering av ytelsen.

1. Dataprosessering for CNN-er
Før man trener et CNN, er dataprosessering et avgjørende steg for å sikre bedre ytelse og raskere konvergens. Vanlige metoder for dataprosessering 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 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))
Parameteren input_shape
skal kun spesifiseres i inngangslaget.
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')
Det siste dense-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 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-algoritmen er populær på grunn av sin effektivitet og evne til å tilpasse læringsraten under trening.
keras.optimizers.Adam()
Tapsfunksjon (Categorical Crossentropy)
For flerkategoriklassifisering 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()
]
Kompiler
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 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 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 parametrene
epochs
ogbatch_size
for trening (f.eks.epochs=20, batch_size=64
); - Spesifiser parameteren
validation_split
for å angi prosentandel av treningsdata som blir valideringsdata for å spore modellens ytelse på usette 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.
Takk for tilbakemeldingene dine!
Spør AI
Spør AI
Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår
Can you provide a sample code for loading and preprocessing the CIFAR-10 dataset?
How do I implement the VGG-like CNN architecture in Keras?
What are the recommended values for epochs and batch size for training this model?
Awesome!
Completion rate improved to 3.45
Utfordring: Bygge et CNN
Sveip for å vise menyen
Konvolusjonsnevrale 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 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 veileder deg gjennom lasting av datasettet, bildebehandling, definering av CNN-modellen, trening og evaluering av ytelsen.

1. Dataprosessering for CNN-er
Før man trener et CNN, er dataprosessering et avgjørende steg for å sikre bedre ytelse og raskere konvergens. Vanlige metoder for dataprosessering 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 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))
Parameteren input_shape
skal kun spesifiseres i inngangslaget.
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')
Det siste dense-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 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-algoritmen er populær på grunn av sin effektivitet og evne til å tilpasse læringsraten under trening.
keras.optimizers.Adam()
Tapsfunksjon (Categorical Crossentropy)
For flerkategoriklassifisering 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()
]
Kompiler
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 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 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 parametrene
epochs
ogbatch_size
for trening (f.eks.epochs=20, batch_size=64
); - Spesifiser parameteren
validation_split
for å angi prosentandel av treningsdata som blir valideringsdata for å spore modellens ytelse på usette 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.
Takk for tilbakemeldingene dine!