Egy intuitív útmutató a konvolúciós neurális hálózatokhoz

Ebben a cikkben a konvolúciós ideghálózatokat (CNN) vizsgáljuk meg, és magas szinten át fogjuk vizsgálni, hogyan inspirálja őket az agy szerkezete. Ha konkrétan többet szeretne megtudni az agyról, a cikk végén további források találhatók, amelyek tovább segítenek.

Az agy

Folyamatosan elemezzük a körülöttünk lévő világot. Tudatos erőfeszítések nélkül előrejelzést adunk mindarról, amit látunk, és cselekszünk ezek alapján. Ha látunk valamit, minden tárgyat felcímkézünk a múltban tanultak alapján. Ennek szemléltetésére nézze meg ezt a képet egy pillanatra.

Valószínűleg valami olyasmit gondoltál, hogy „ez egy boldog kisfiú áll egy széken”. Vagy talán azt hitted, hogy úgy néz ki, mintha sikítana, hamarosan megtámadja ezt a tortát maga előtt.

Ezt tudat alatt egész nap csináljuk. Látjuk, megcímkézzük, jóslatokat készítünk és felismerjük a mintákat. De hogyan csináljuk ezt? Hogyan lehet mindent értelmezni, amit látunk?

A természet létrehozásához több mint 500 millió év kellett a rendszer létrehozásához. A szem és az agy közötti együttműködés, amelyet elsődleges vizuális útnak nevezünk, az az oka, hogy értelmet nyerhetünk a körülöttünk lévő világban.

Míg a látás a szemekben kezdődik, a látottak tényleges értelmezése az agyban, az elsődleges vizuális kéregben történik .

Amikor meglát egy tárgyat, a szemében lévő fényreceptorok a látóidegen keresztül jeleket küldenek az elsődleges vizuális kéregbe, ahol a bemenetet feldolgozzák. Az elsődleges vizuális kéregnek van értelme annak, amit a szem lát.

Mindez nagyon természetesnek tűnik számunkra. Alig gondolkodunk azon, mennyire különleges, hogy képesek vagyunk felismerni az életünkben látott összes tárgyat és embert. Az idegsejtek mélyen összetett hierarchikus felépítése és az agyi kapcsolatok nagy szerepet játszanak ebben a tárgyak emlékezésének és címkézésének folyamatában.

Gondoljon arra, hogyan tanultuk meg például az esernyőt. Vagy kacsa, lámpa, gyertya vagy könyv. Kezdetben szüleink vagy családunk elmondta a közvetlen környezetünkben lévő tárgyak nevét. A számunkra adott példákkal tanultunk. Lassan, de biztosan kezdtünk felismerni bizonyos dolgokat a környezetünkben. Olyan gyakoriak lettek, hogy amikor legközelebb meglátjuk őket, azonnal megtudjuk, mi ennek a tárgynak a neve. A világ modelljének részévé váltak .

Konvolúciós neurális hálózatok

Hasonlóan ahhoz, ahogyan a gyermek megtanulja felismerni az objektumokat, több millió képet kell bemutatnunk egy algoritmusnak, mielőtt képes lenne általánosítani a bemenetet és megjósolni azokat a képeket, amelyeket még soha nem látott.

A számítógépek másképp „látnak”, mint mi. Világuk csak számokból áll. Minden kép ábrázolható kétdimenziós számtömbként, pixel néven.

Az a tény azonban, hogy másképp érzékelik a képeket, nem jelenti azt, hogy nem képezhetjük ki őket a minták felismerésére, mint mi. Csak arra kell gondolnunk, hogy mi a kép másképp.

Ahhoz, hogy egy algoritmust megtanítsunk a képeken lévő objektumok felismerésére, egy mesterséges neurális hálózatot használunk: egy konvolúciós neurális hálózatot (CNN). Nevük a hálózat egyik legfontosabb műveletéből ered: a konvolúcióból.

A konvolúciós neurális hálózatokat az agy inspirálja. Az 1950-es és 1960-as években DH Hubel és TN Wiesel kutatása az emlősök agyával kapcsolatban új modellt javasolt arra, hogy az emlősök hogyan érzékelik a világot vizuálisan. Megmutatták, hogy a macska és a majom vizuális kérge magában foglalja azokat az idegsejteket, amelyek kizárólag közvetlen környezetükben reagálnak az idegsejtekre.

Dolgozatukban az agy két vizuális neuronsejtjének alapvető típusát írták le, amelyek mindegyike másképpen hat: egyszerű sejtek ( S-sejtek ) és komplex sejtek ( C-sejtek ).

Az egyszerű cellák például akkor aktiválódnak, amikor az alapalakokat rögzített területen és meghatározott szögben vonalakként azonosítják. A komplex sejtek nagyobb befogadó mezővel rendelkeznek, és kimenetük nem érzékeny a mező adott helyzetére.

A komplex sejtek továbbra is reagálnak egy bizonyos ingerre, annak ellenére, hogy abszolút helyzete a retinán megváltozik. A Complex ebben az esetben a rugalmasabbakra utal.

A látásban egyetlen érzékszervi idegsejt befogadó területe a retina sajátos régiója, amelyben valami befolyásolja az adott idegsejt kilövését (vagyis aktiválja az idegsejtet). Minden érzékszervi idegsejtnek hasonló a befogadó mezője, és azok mezői fedik egymást.

Továbbá a hierarchia fogalma jelentős szerepet játszik az agyban. Az információkat minták sorozatában, sorrendben tároljuk. A neokortex , amely az agy legkülső rétege, hierarchikusan tárolja az információkat. Kortikális oszlopokban, vagy a neocortex idegsejtjeinek egységesen szervezett csoportjaiban tárolódik.

1980-ban egy Fukushima nevű kutató hierarchikus ideghálózati modellt javasolt. Ő nevezte a neocognitron . Ezt a modellt a Simple és a Complex sejtek koncepciói ihlették. A neokognitron a tárgyak alakjának megismerésével képes volt felismerni a mintákat.

Később, 1998-ban Bengio, Le Cun, Bottou és Haffner dolgozatában bemutatták a konvolúciós neurális hálózatokat. Első konvolúciós neurális hálózatukat LeNet-5- nek hívták, és képes volt a számjegyek osztályozására a kézzel írott számokból.

A konvolúciós ideghálók teljes története során ide mehet.

Építészet

A cikk további részében áttekintem a CNN architektúráját, és bemutatom a Python implementációt is.

A konvolúciós neurális hálózatok architektúrája más, mint a szokásos neurális hálózatoké. A rendszeres neurális hálózatok átalakítják a bemenetet rejtett rétegek sorozatán keresztül. Minden réteg idegsejtekből áll , ahol minden réteg teljesen kapcsolódik az előző réteg összes neuronjához. Végül van egy utolsó, teljesen összekapcsolt réteg - a kimeneti réteg -, amely a jóslatokat képviseli.

A konvolúciós neurális hálózatok kissé eltérnek egymástól. Először is, a rétegek 3 dimenzióban vannak elrendezve : szélesség, magasság és mélység. Továbbá az egy rétegben található idegsejtek nem a következő réteg összes idegsejtjéhez kapcsolódnak, hanem csak annak egy kis régiójához. Végül a végső kimenetet a valószínűségi pontszámok egyetlen vektorává redukáljuk, a mélység dimenzió mentén szerveződve.

A CNN-nek két összetevője van:

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

More brain related recommendations?

  • Read this really cool article on the brain and more.
  • I also recommend this book on intelligence and the brain.
  • “How to Create a Mind” by Ray Kurzweil.