**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))
```

`input_shape`-parameteren skal kun angives i inputlaget.

Bemærk

### 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')
```

Det sidste tætte lag har typisk et antal enheder **svarende til antallet af klasser** og anvender en **softmax aktiveringsfunktion** for at give en sandsynlighedsfordeling på tværs af klasserne.

## 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:
<img
  src="https://content-media-cdn.codefinity.com/courses/ef049f7b-ce21-45be-a9f2-5103360b0655/section_3/challenge/architecture.png"
alt="VGG like architecture"
  style="max-width: 100%; width: auto; border-radius: 10px"
/>

**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.



<a href="https://colab.research.google.com/drive/1UHxOIZwAhMfdQSTQBavzmdayuC8X-mf5?usp=sharing" target="_blank"><svg width="1em" height="1em" viewBox="0 0 30 32" fill="none" xmlns="http://www.w3.org/2000/svg"><path fill="none" stroke="#098f67" style="stroke: var(--color1, #098f67)" stroke-linejoin="miter" stroke-linecap="round" stroke-miterlimit="4" stroke-width="2.4156" d="M17.289 17.305v0c-1.754 1.754-4.597 1.754-6.351 0l-7.76-7.759c-1.755-1.755-1.755-4.601 0-6.356v0c1.753-1.753 4.595-1.756 6.351-0.005l6.208 6.187"></path><path fill="none" stroke="#098f67" style="stroke: var(--color1, #098f67)" stroke-linejoin="miter" stroke-linecap="round" stroke-miterlimit="4" stroke-width="2.4156" d="M12.504 13.97v0c1.754-1.754 4.597-1.754 6.351 0l7.762 7.762c1.754 1.754 1.754 4.597 0 6.351v0c-1.754 1.754-4.597 1.754-6.351 0l-5.953-5.953"></path></svg> COLAB CNN PROJEKT</a>

Omfattende introduktion til Computer Vision med fokus på maskinens opfattelse og fortolkning af visuelle data. Dækker billedforbehandling, feature-ekstraktion, objektdetektion og dybdelæringsteknikker anvendt i moderne visionssystemer.

Computer vision gør det muligt for maskiner at fortolke og analysere visuelle data ved at efterligne menneskelig perception. Dette afsnit dækker grundlæggende billedrepræsentation, farvemodeller og matematiske fundamenter, som er essentielle for at forstå, hvordan computere behandler billeder. Du vil udforske virkelige anvendelser, fra autonome køretøjer til medicinsk billedbehandling, og få indsigt i, hvordan computer vision integreres med AI og maskinlæring.

OpenCV er et kraftfuldt bibliotek til billedmanipulation og computer vision-opgaver. Dette afsnit dækker væsentlige teknikker såsom billedfiltrering, transformationer, kantdetektion og segmentering. Du lærer at udføre sløring, tærskling, konturdetektion og feature-ekstraktion for at forbedre og analysere billeder effektivt.

CNN'er behandler visuelle data ved hjælp af konvolution, pooling og aktiveringslag for at udtrække træk til opgaver som billedklassificering og objektdetektion. Centrale komponenter omfatter padding, konvolution til trækudtrækning, pooling til reduktion af kompleksitet og aktivering for ikke-linearitet. Populære arkitekturer som AlexNet, VGG og ResNet driver AI inden for sundhedspleje, autonomi og sikkerhed.

Objektdetektion er en grundlæggende opgave inden for computer vision, der omfatter identifikation og lokalisering af objekter i et billede. I modsætning til billedklassificering, som tildeler en enkelt etiket til et helt billede, klassificerer objektdetektion ikke kun objekter, men bestemmer også deres positioner ved hjælp af afgrænsningsbokse. Dette afsnit dækker centrale teknikker og algoritmer anvendt i objektdetektion, fra traditionelle metoder til dybdelæringsbaserede tilgange som YOLO og U-Net.

Computer vision har gennemgået betydelige fremskridt gennem årene, fra grundlæggende billedbehandlingsmetoder til avancerede deep learning-teknikker. Dette afsnit undersøger de nyeste innovationer inden for computer vision med fokus på transfer learning, ansigtsgenkendelse og billedgenerering. Vi udforsker fordelene ved prætrænede modeller for ydeevne, principperne bag ansigtsgenkendelsesteknologi samt hvordan AI skaber billeder ved hjælp af deep learning.

Udfordring: Opbygning af et CNN

Awesome!

Udfordring: Opbygning af et CNN