En intuitiv guide til konvolutionelle neurale netværk

I denne artikel vil vi undersøge Convolutional Neural Networks (CNNs) og på et højt niveau gennemgå, hvordan de er inspireret af hjernens struktur. Hvis du vil læse mere om hjernen specifikt, er der flere ressourcer i slutningen af ​​artiklen for at hjælpe dig yderligere.

Hjernen

Vi analyserer konstant verden omkring os. Uden bevidst indsats forudsiger vi alt, hvad vi ser, og handler efter dem. Når vi ser noget, mærker vi hvert objekt ud fra det, vi tidligere har lært. For at illustrere dette skal du se et øjeblik på dette billede.

Du tænkte sandsynligvis noget som "det er en glad lille dreng, der står på en stol". Eller måske troede du, at han ser ud som om han skriger, ved at angribe denne kage foran ham.

Dette er hvad vi ubevidst gør hele dagen. Vi ser, mærker, forudsiger og genkender mønstre. Men hvordan gør vi det? Hvordan kan det være, at vi kan fortolke alt det, vi ser?

Det tog naturen mere end 500 millioner år at oprette et system til at gøre dette. Samarbejdet mellem øjnene og hjernen, kaldet den primære visuelle vej, er grunden til, at vi kan give mening om verden omkring os.

Mens synet starter i øjnene, sker den faktiske fortolkning af det, vi ser, i hjernen i den primære visuelle cortex .

Når du ser et objekt, sender lysreceptorerne i dine øjne signaler via optisk nerve til den primære visuelle cortex, hvor input behandles. Den primære visuelle cortex giver mening af, hvad øjet ser.

Alt dette synes meget naturligt for os. Vi tænker næppe på, hvor specielt det er, at vi er i stand til at genkende alle de objekter og mennesker, vi ser i vores liv. Den dybt komplekse hierarkiske struktur af neuroner og forbindelser i hjernen spiller en vigtig rolle i denne proces med at huske og mærke objekter.

Tænk over, hvordan vi lærte, hvad for eksempel en paraply er. Eller en and, lampe, lys eller bog. I begyndelsen fortalte vores forældre eller familien os, hvad objektene hedder i vores direkte miljø. Vi lærte med eksempler, der blev givet os. Langsomt men sikkert begyndte vi at genkende visse ting oftere og oftere i vores miljø. De blev så almindelige, at næste gang vi så dem, ville vi straks vide, hvad navnet på dette objekt var. De blev en del af vores model på verden.

Konvolutionsneurale netværk

På samme måde som et barn lærer at genkende objekter, skal vi vise en algoritme millioner af billeder, før det er i stand til at generalisere input og forudsige billeder, som det aldrig har set før.

Computere 'ser' på en anden måde end vi gør. Deres verden består kun af tal. Hvert billede kan repræsenteres som 2-dimensionelle række af tal, kendt som pixels.

Men det faktum, at de opfatter billeder på en anden måde, betyder ikke, at vi ikke kan træne dem til at genkende mønstre, som vi gør. Vi skal bare tænke på, hvad et billede er på en anden måde.

For at lære en algoritme, hvordan man genkender objekter i billeder, bruger vi en bestemt type kunstigt neuralt netværk: et Convolutional Neural Network (CNN). Deres navn stammer fra en af ​​de vigtigste operationer i netværket: foldning.

Convolutional Neural Networks er inspireret af hjernen. Forskning i 1950'erne og 1960'erne af DH Hubel og TN Wiesel på pattedyrs hjerne foreslog en ny model for, hvordan pattedyr opfatter verden visuelt. De viste, at visuelle cortex fra kat og abe inkluderer neuroner, der udelukkende reagerer på neuroner i deres direkte miljø.

I deres papir beskrev de to basistyper af visuelle neuronceller i hjernen, som hver handler på en anden måde: enkle celler ( S-celler ) og komplekse celler ( C-celler ).

De enkle celler aktiveres for eksempel, når de identificerer grundlæggende former som linjer i et fast område og en bestemt vinkel. De komplekse celler har større modtagelige felter, og deres output er ikke følsom over for den specifikke position i marken.

De komplekse celler fortsætter med at reagere på en bestemt stimulus, selvom dens absolutte position på nethinden ændres. Kompleks refererer til mere fleksibel, i dette tilfælde.

I synet er et modtageligt felt i en enkelt sensorisk neuron den specifikke region i nethinden, hvor noget vil påvirke affyringen af ​​det neuron (det vil sige aktivt neuronet). Hver sensorisk neuroncelle har lignende modtagelige felter, og deres felter ligger overliggende.

Yderligere spiller begrebet hierarki en vigtig rolle i hjernen. Information gemmes i mønstre i rækkefølge. Den neocortex , som er det yderste lag af hjernen, gemmer oplysninger hierarkisk. Det opbevares i kortikale kolonner eller ensartede organiserede grupperinger af neuroner i neokortexen.

I 1980 foreslog en forsker kaldet Fukushima en hierarkisk neuralt netværksmodel. Han kaldte det neokognitronen . Denne model blev inspireret af koncepterne i de enkle og komplekse celler. Neokognitronen var i stand til at genkende mønstre ved at lære om objekternes former.

Senere, i 1998, blev Convolutional Neural Networks introduceret i et papir af Bengio, Le Cun, Bottou og Haffner. Deres første Convolutional Neural Network blev kaldt LeNet-5 og var i stand til at klassificere cifre fra håndskrevne tal.

For hele historien om Convolutional Neural Net, kan du gå her.

Arkitektur

I den resterende del af denne artikel tager jeg dig gennem arkitekturen i et CNN og viser dig også Python-implementeringen.

Konvolutionsneurale netværk har en anden arkitektur end almindelige neurale netværk. Regelmæssige neurale netværk transformerer et input ved at placere det gennem en række skjulte lag. Hvert lag består af et sæt neuroner , hvor hvert lag er fuldt forbundet med alle neuroner i laget før. Endelig er der et sidste fuldt tilsluttede lag - outputlaget - der repræsenterer forudsigelserne.

Convolutional Neural Networks er lidt anderledes. Først og fremmest er lagene organiseret i 3 dimensioner : bredde, højde og dybde. Endvidere forbinder neuronerne i det ene lag ikke med alle neuronerne i det næste lag, men kun til et lille område af det. Endelig reduceres det endelige output til en enkelt vektor med sandsynlighedsresultater, organiseret efter dybdedimensionen.

CNN'er har to komponenter:

  • The Hidden layers/Feature extraction part

In this part, the network will perform a series of convolutions and pooling operations during which the features are detected. If you had a picture of a zebra, this is the part where the network would recognise its stripes, two ears, and four legs.

  • The Classification part

Here, the fully connected layers will serve as a classifier on top of these extracted features. They will assign a probability for the object on the image being what the algorithm predicts it is.

# before we start building we import the libraries
import numpy as np
from keras.layers import Conv2D, Activation, MaxPool2D, Flatten, Densefrom keras.models import Sequential

Feature extraction

Convolution is one of the main building blocks of a CNN. The term convolution refers to the mathematical combination of two functions to produce a third function. It merges two sets of information.

In the case of a CNN, the convolution is performed on the input data with the use of a filter or kernel (these terms are used interchangeably)to then produce a feature map.

We execute a convolution by sliding the filter over the input. At every location, a matrix multiplication is performed and sums the result onto the feature map.

In the animation below, you can see the convolution operation. You can see the filter (the green square) is sliding over our input (the blue square) and the sum of the convolution goes into the feature map (the red square).

The area of our filter is also called the receptive field, named after the neuron cells! The size of this filter is 3x3.

For the sake of explaining, I have shown you the operation in 2D, but in reality convolutions are performed in 3D. Each image is namely represented as a 3D matrix with a dimension for width, height, and depth. Depth is a dimension because of the colours channels used in an image (RGB).

We perfom numerous convolutions on our input, where each operation uses a different filter. This results in different feature maps. In the end, we take all of these feature maps and put them together as the final output of the convolution layer.

Just like any other Neural Network, we use an activation function to make our output non-linear. In the case of a Convolutional Neural Network, the output of the convolution will be passed through the activation function. This could be the ReLU activation function.

Stride is the size of the step the convolution filter moves each time. A stride size is usually 1, meaning the filter slides pixel by pixel. By increasing the stride size, your filter is sliding over the input with a larger interval and thus has less overlap between the cells.

The animation below shows stride size 1 in action.

Because the size of the feature map is always smaller than the input, we have to do something to prevent our feature map from shrinking. This is where we use padding.

A layer of zero-value pixels is added to surround the input with zeros, so that our feature map will not shrink. In addition to keeping the spatial size constant after performing convolution, padding also improves performance and makes sure the kernel and stride size will fit in the input.

After a convolution layer, it is common to add a pooling layer in between CNN layers. The function of pooling is to continuously reduce the dimensionality to reduce the number of parameters and computation in the network. This shortens the training time and controls overfitting.

The most frequent type of pooling is max pooling,which takes the maximum value in each window. These window sizes need to be specified beforehand. This decreases the feature map size while at the same time keeping the significant information.

Thus when using a CNN, the four important hyperparameters we have to decide on are:

  • the kernel size
  • the filter count (that is, how many filters do we want to use)
  • stride (how big are the steps of the filter)
  • padding
# Images fed into this model are 512 x 512 pixels with 3 channels
img_shape = (28,28,1)
# Set up the model
model = Sequential()
# Add convolutional layer with 3, 3 by 3 filters and a stride size of 1# Set padding so that input size equals output size
model.add(Conv2D(6,2,input_shape=img_shape))
# Add relu activation to the layer 
model.add(Activation('relu'))
#Pooling
model.add(MaxPool2D(2))

A nice way of visualizing a convolution layer is shown below. Try to look at it for a bit and really understand what is happening.

Classification

After the convolution and pooling layers, our classification part consists of a few fully connected layers. However, these fully connected layers can only accept 1 Dimensional data. To convert our 3D data to 1D, we use the function flatten in Python. This essentially arranges our 3D volume into a 1D vector.

The last layers of a Convolutional NN are fully connected layers. Neurons in a fully connected layer have full connections to all the activations in the previous layer. This part is in principle the same as a regular Neural Network.

#Fully connected layers
# Use Flatten to convert 3D data to 1Dmodel.add(Flatten())
# Add dense layer with 10 neuronsmodel.add(Dense(10))
# we use the softmax activation function for our last layermodel.add(Activation('softmax'))
# give an overview of our model
model.summary
_________________________________________________________________Layer (type) Output Shape Param # =================================================================conv2d_1 (Conv2D) (None, 27, 27, 6) 30 _________________________________________________________________activation_1 (Activation) (None, 27, 27, 6) 0 _________________________________________________________________max_pooling2d_1 (MaxPooling2 (None, 13, 13, 6) 0 _________________________________________________________________flatten_1 (Flatten) (None, 1014) 0 _________________________________________________________________dense_1 (Dense) (None, 10) 10150 _________________________________________________________________activation_2 (Activation) (None, 10) 0 =================================================================Total params: 10,180Trainable params: 10,180Non-trainable params: 0__________________________________________________________________

Training

Training a CNN works in the same way as a regular neural network, using backpropagration or gradient descent. However, here this is a bit more mathematically complex because of the convolution operations.

If you would like to read more about how regular neural nets work, you can read my previous article.

"""Before the training process, we have to put together a learning process in a particular form. It consists of 3 elements: an optimiser, a loss function and a metric."""
model.compile(loss='sparse_categorical_crossentropy', optimizer = 'adam', metrics=['acc'])
# dataset with handwritten digits to train the model onfrom keras.datasets import mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = np.expand_dims(x_train,-1)
x_test = np.expand_dims(x_test,-1)
# Train the model, iterating on the data in batches of 32 samples# for 10 epochs
model.fit(x_train, y_train, batch_size=32, epochs=10, validation_data=(x_test,y_test)
# Training...
Train on 60000 samples, validate on 10000 samplesEpoch 1/1060000/60000 [==============================] - 10s 175us/step - loss: 4.0330 - acc: 0.7424 - val_loss: 3.5352 - val_acc: 0.7746Epoch 2/1060000/60000 [==============================] - 10s 169us/step - loss: 3.5208 - acc: 0.7746 - val_loss: 3.4403 - val_acc: 0.7794Epoch 3/1060000/60000 [==============================] - 11s 176us/step - loss: 2.4443 - acc: 0.8372 - val_loss: 1.9846 - val_acc: 0.8645Epoch 4/1060000/60000 [==============================] - 10s 173us/step - loss: 1.8943 - acc: 0.8691 - val_loss: 1.8478 - val_acc: 0.8713Epoch 5/1060000/60000 [==============================] - 10s 174us/step - loss: 1.7726 - acc: 0.8735 - val_loss: 1.7595 - val_acc: 0.8718Epoch 6/1060000/60000 [==============================] - 10s 174us/step - loss: 1.6943 - acc: 0.8765 - val_loss: 1.7150 - val_acc: 0.8745Epoch 7/1060000/60000 [==============================] - 10s 173us/step - loss: 1.6765 - acc: 0.8777 - val_loss: 1.7268 - val_acc: 0.8688Epoch 8/1060000/60000 [==============================] - 10s 173us/step - loss: 1.6676 - acc: 0.8799 - val_loss: 1.7110 - val_acc: 0.8749Epoch 9/1060000/60000 [==============================] - 10s 172us/step - loss: 1.4759 - acc: 0.8888 - val_loss: 0.1346 - val_acc: 0.9597Epoch 10/1060000/60000 [==============================] - 11s 177us/step - loss: 0.1026 - acc: 0.9681 - val_loss: 0.1144 - val_acc: 0.9693

Summary

In summary, CNNs are especially useful for image classification and recognition. They have two main parts: a feature extraction part and a classification part.

The main special technique in CNNs is convolution, where a filter slides over the input and merges the input value + the filter value on the feature map. In the end, our goal is to feed new images to our CNN so it can give a probability for the object it thinks it sees or describe an image with text.

You can find the entire code here.

Flere hjernerelaterede anbefalinger?

  • Læs denne rigtig seje artikel om hjernen og mere.
  • Jeg anbefaler også denne bog om intelligens og hjernen.
  • “Sådan oprettes et sind” af Ray Kurzweil.