Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.
Lære Utfordring: Bygge et CNN | Konvolusjonelle Nevrale Nettverk
Grunnleggende Datamaskinsyn

bookUtfordring: 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.

CIFAR10

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))
Note
Merk

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')
Note
Merk

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: VGG like architecture

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 og batch_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.

COLAB CNN-PROSJEKT

question-icon

Skriv inn delene av nøkkelen (Du mottok dem etter at du hadde fullført prosjektet)

1.  2.  3.  4.  5.
Alt var klart?

Hvordan kan vi forbedre det?

Takk for tilbakemeldingene dine!

Seksjon 3. Kapittel 7

Spør AI

expand

Spør AI

ChatGPT

Spør om hva du vil, eller prøv ett av de foreslåtte spørsmålene for å starte chatten vår

Suggested prompts:

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

bookUtfordring: 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.

CIFAR10

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))
Note
Merk

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')
Note
Merk

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: VGG like architecture

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 og batch_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.

COLAB CNN-PROSJEKT

question-icon

Skriv inn delene av nøkkelen (Du mottok dem etter at du hadde fullført prosjektet)

1.  2.  3.  4.  5.
Alt var klart?

Hvordan kan vi forbedre det?

Takk for tilbakemeldingene dine!

Seksjon 3. Kapittel 7
some-alt