Konvolutionella neurala nätverk (CNNs) används i stor utsträckning för bildklassificering tack vare deras förmåga att extrahera hierarkiska egenskaper. I denna uppgift kommer du att implementera och träna en VGG-liknande CNN med TensorFlow och Keras på CIFAR-10-datasetet. Datasetet består av 60 000 bilder (32×32×3) som tillhör 10 olika klasser, inklusive flygplan, bilar, fåglar, katter och fler.

Detta projekt vägleder dig genom inläsning av datasetet, förbehandling av bilder, definition av CNN-modellen, träning samt utvärdering av dess prestanda.

1. Databehandling för CNNs

Innan träning av en CNN är förbehandling av data ett avgörande steg för att säkerställa bättre prestanda och snabbare konvergens. Vanliga förbehandlingsmetoder inkluderar:

• Normalisering: denna metod innebär att skala pixelvärdena i bilder från ett intervall mellan 0 och 255 till ett intervall mellan 0 och 1. Det implementeras ofta som x_train / 255.0, x_test / 255.0;

• One-hot-kodning: etiketter konverteras ofta till one-hot-kodade vektorer för klassificeringsuppgifter. Detta görs vanligtvis med funktionen keras.utils.to_categorical, som omvandlar heltalsetiketter (t.ex. 0, 1, 2, etc.) till en one-hot-kodad vektor, såsom [1, 0, 0, 0] för ett 4-klasser klassificeringsproblem.

2. Bygga CNN-arkitekturen

En CNN-arkitektur består av flera lager som utför olika uppgifter för att extrahera egenskaper och göra förutsägelser. Du kan implementera viktiga CNN-lager genom:

Konvolutionellt lager (Conv2D)

Observera

input_shape-parametern behöver du endast ange i inmatningslagret.

Pooling-lager (MaxPooling2D)

Flatten-lager

Dense Layer

Observera

Det slutliga täta lagret har vanligtvis antalet enheter lika med antalet klasser och använder en softmax-aktiveringsfunktion för att generera en sannolikhetsfördelning över klasserna.

3. Modellkompilering

Efter att arkitekturen har definierats behöver modellen kompileras. Detta steg innebär att specificera förlustfunktion, optimerare och metrik som kommer att styra modellen under träningen. Följande metoder används ofta i CNN:

Optimerare (Adam)

Optimeraren justerar modellens vikter för att minimera förlustfunktionen. Adam-optimeraren är populär tack vare sin effektivitet och förmåga att anpassa inlärningshastigheten under träningen.

Förlustfunktion (Kategorisk korsentropi)

För flervalsklassificering används vanligtvis kategorisk korsentropi som förlustfunktion. Detta kan implementeras som:

Mätvärden

Modellens prestanda övervakas med hjälp av mätvärden för klassificeringsuppgifter, såsom noggrannhet, precision, återkallelse, etc. Dessa kan definieras som:

Kompilera

4. Träning av modellen

Träning av ett CNN innebär att mata indata till nätverket, beräkna förlusten och uppdatera vikterna med hjälp av backpropagation. Träningsprocessen styrs av följande nyckelmetoder:

• Träna modellen: Metoden fit() används för att träna modellen. Denna metod tar emot träningsdata, antal epoker och batch-storlek. Det finns även en valfri valideringsdelning för att utvärdera modellens prestanda på osedda data under träningen:

• Batch-storlek och epoker: Batch-storleken avgör antalet prover som behandlas innan modellens vikter uppdateras, och antalet epoker avser hur många gånger hela datamängden passerar genom modellen.

5. Utvärdering

Klassificeringsrapport

sklearn.metrics.classification_report() jämför sanna och förutsagda värden från testdatamängden. Den inkluderar precision, recall och F1-score för varje klass. Men metoderna behöver endast klassetiketter, så glöm inte att konvertera tillbaka från vektorer ([0,0,1,0] -> 2):

Utvärdera

När modellen har tränats utvärderas den på testdatamängden för att bedöma dess generaliseringsförmåga. Utvärderingen ger mått, vilka nämndes i .compile()-metoden. Utvärderingen utförs med hjälp av .evaluate():

Konfusionsmatris

För att få djupare insikt i modellens prestanda kan vi visualisera konfusionsmatrisen, som visar sanna positiva, falska positiva, sanna negativa och falska negativa prediktioner för varje klass. Konfusionsmatrisen kan beräknas med TensorFlow:

Denna matris kan sedan visualiseras med hjälp av värmekartor för att observera hur väl modellen presterar på varje klass:

1. Ladda och förbehandla datasetet

• Importera CIFAR-10-datasetet från Keras;

• Normalisera pixelvärdena till intervallet [0,1] för bättre konvergens;

• Konvertera klassetiketterna till one-hot encoded format för kategorisk klassificering.

2. Definiera CNN-modellen

Implementera en VGG-liknande CNN-arkitektur med följande nyckellager:

Konvolutionslager:

• Kärnstorlek: 3×3;

• Aktiveringsfunktion: ReLU;

• Padding: 'same'.

Poolinglager:

• Poolingtyp: max pooling;

• Poolingstorlek: 2×2.

Dropout-lager (Förhindra överanpassning genom att slumpmässigt inaktivera neuroner):

• Dropout-nivå: 25%.

Flatten-lager – konvertera 2D-funktionskartor till en 1D-vektor för klassificering.

Fullt anslutna lager – täta lager för slutlig klassificering, med ett relu- eller softmax-utgångslager.

Kompilera modellen med:

• Adam optimizer (för effektiv inlärning);

• Categorical cross-entropy förlustfunktion (för flervalsklassificering);

• Accuracy metric för att mäta prestanda (klasserna är balanserade, och du kan lägga till andra metrik på egen hand).

3. Träna modellen

• Ange parametrarna epochs och batch_size för träning (t.ex. epochs=20, batch_size=64);

• Ange parametern validation_split för att definiera procentandel av träningsdata som blir valideringsdata för att följa modellens prestanda på osedda bilder;

• Spara träningshistoriken för att visualisera noggrannhets- och förlusttrender.

4. Utvärdera och visualisera resultat

• Testa modellen på CIFAR-10 testdata och skriv ut noggrannheten;

• Plotta träningsförlust vs. valideringsförlust för att kontrollera överanpassning;

• Plotta träningsnoggrannhet vs. valideringsnoggrannhet för att säkerställa inlärningsprogression.

COLAB CNN-PROJEKT