Introduktion til billeddata

I computer vision løser vi normalt et af følgende problemer:

• Billedklassificering er den simpleste opgave, når vi skal klassificere et billede i en af mange foruddefinerede kategorier, for eksempel skelne en kat fra en hund på et fotografi eller genkende et håndskrevet ciffer.
• Objektdetektion er en lidt mere vanskelig opgave, hvor vi skal finde kendte objekter på billedet og lokalisere dem, det vil sige returnere afgrænsningsboksen for hvert af de genkendte objekter.
• Segmentering ligner objektdetektion, men i stedet for at give en afgrænsningsboks skal vi returnere et nøjagtigt pixelkort, der markerer hver af de genkendte objekter.

Billede fra CS231n Stanford-kurset

Billeder som tensorer

Computer Vision arbejder med billeder. Som du sikkert ved, består billeder af pixels, så de kan betragtes som en rektangulær samling (array) af pixels.

I den første del af dette modul vil vi beskæftige os med håndskrevet ciffergenkendelse. Vi bruger MNIST-datasættet, som består af gråtonebilleder af håndskrevne cifre, 28x28 pixels. Hvert billede kan repræsenteres som et 28x28 array, og elementer i dette array vil angive intensiteten af den tilsvarende pixel – enten i skalaen fra 0 til 1 (hvor flydende kommatal) eller 0 til 255 (heltal). Et populært Python-bibliotek kaldet numpy bruges ofte til computer vision-opgaver, fordi det gør det muligt effektivt at arbejde med multidimensionelle arrays.

For at håndtere farvebilleder har vi brug for en måde at repræsentere farver på. I de fleste tilfælde repræsenterer vi hver pixel med 3 intensitetsværdier, svarende til Rød (R), Grøn (G) og Blå (B) komponenter. Denne farvekodning kaldes RGB, og derfor vil farvebillede af størrelse W×H blive repræsenteret som et array af størrelse H×W×3 (nogle gange kan rækkefølgen af komponenterne være forskellig, men idéen er den samme). I array-repræsentation kommer højden (antallet af rækker) før bredden (antal kolonner), hvilket er det modsatte af den almindelige billedkonvention for W×H.

Multidimensionale arrays kaldes også tensorer. Brugen af tensorer til at repræsentere billeder har også en fordel, fordi vi kan bruge en ekstra dimension til at gemme en sekvens af billeder. For eksempel, for at repræsentere et videofragment bestående af 200 billeder med 800x600 dimension (bredde × højde), kan vi bruge tensoren af størrelse 200x600x800x3. Husk, at tensordimensioner bruger H×W (række-major) rækkefølge, ikke W×H-konventionen, som ofte ses i billedredigeringsprogrammer. Rækkefølgen her er rammer × højde (600) × bredde (800) × kanaler. Denne rækkefølge er kendt som channels_last og er standard i TensorFlow; nogle andre frameworks placerer kanaler før højde og bredde (channels_first).

import tensorflow as tf
import keras
import matplotlib.pyplot as plt
import numpy as np

# Prints the installed TensorFlow version
print(tf.__version__)

Vi vil bruge Keras-rammen til vores eksperimenter. I hele dette modul bruger import keras vi (den selvstændige Keras 3 importstil), som kræver TensorFlow 2.16 eller nyere (eller en selvstændig installation via pip install keras>=3.0). Hvis du bruger en ældre TensorFlow 2.x-version, så erstat import keras med from tensorflow import keras.

(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Output: (60000, 28, 28) (60000,)
print(x_train.shape, y_train.shape)
# Output: (10000, 28, 28) (10000,)
print(x_test.shape, y_test.shape)

Visualiser cifredatasættet

Nu hvor vi har downloadet datasættet, kan vi visualisere nogle af cifrene:

fig, ax = plt.subplots(1, 7)
for i in range(7):
    ax[i].imshow(x_train[i])
    ax[i].set_title(y_train[i])
    ax[i].axis('off')
# Displays a row of seven handwritten digit images with their labels

Datasætstruktur

Vi har i alt 60.000 træningsbilleder og 10.000 testbilleder, og hvert billede har en størrelse på 28×28 pixels:

print('Training samples:', len(x_train))
print('Test samples:', len(x_test))
print('Tensor size:', x_train[0].shape)
print('First 10 digits are:', y_train[:10])
print('Type of data is ', type(x_train))
# Output:
# Training samples: 60000
# Test samples: 10000
# Tensor size: (28, 28)
# First 10 digits are: [5 0 4 1 9 2 1 3 1 4]
# Type of data is  <class 'numpy.ndarray'>

Som du kan se, er typen af data array numpy . Hver pixelintensitet repræsenteres af en heltalsværdi mellem 0 og 255:

print('Min intensity value: ', x_train.min())
print('Max intensity value: ', x_train.max())
# Output:
# Min intensity value:  0
# Max intensity value:  255

Grunden til, at den ligger mellem 0 og 255, er, at hver pixel repræsenteres af et 8-bit heltal. I mange tilfælde, især når man arbejder med neurale netværk, er det mere bekvemt at skalere alle værdier til intervallet [0, 1] ved at dividere med 255. Denne proces kaldes normalisering:

x_train = x_train.astype(np.float32) / 255.0
x_test = x_test.astype(np.float32) / 255.0
# Pixel values are now floating point numbers in the range [0, 1]

Nu har vi dataene, og vi er klar til at begynde at træne vores første neurale netværk!