Overzicht van de implementatie van neurale netwerken
Kunstmatige neurale netwerken zijn geïnspireerd door biologische neurale netwerken. Neurale netwerken helpen de problemen op te lossen zonder te worden geprogrammeerd met de probleemspecifieke regels en voorwaarden. Het zijn generieke modellen met de meeste complexe wiskundige berekeningen als BlackBox. De verschillende soorten neurale netwerken zijn zoals Convolution Neural Network, Recurrent Neural Network, Feedforward Neural Network, Multilayer perceptron en vele anderen. In dit onderwerp horen we graag meer over de implementatie van neurale netwerken.
De architectuur van neurale netwerken
Er zijn 3 lagen voornamelijk in neurale netwerken.
- Invoerlaag
- Verborgen lagen
- Uitvoerlaag
1. Invoerlaag: de invoerlaag bevat de neuronen voor de invoer van functies. Er is ook één afwijking toegevoegd aan de invoerlaag naast de functies. Dus als er n functies zijn, bevat de invoerlaag n + 1 neuronen.
2. Verborgen laag: de verborgen lagen zijn de tussenliggende lagen tussen de invoer- en uitvoerlagen. Er kan een willekeurig aantal verborgen lagen zijn. Het netwerk met meer dan één verborgen laag wordt diepe neurale netwerken genoemd. De neuronen in de verborgen laag krijgen input van de inputlaag en ze geven output aan de outputlaag.
3. Uitvoerlaag: de uitvoerlaag bevat het aantal neuronen op basis van het aantal uitvoerklassen. Als het een classificatieprobleem van meerdere klassen is, bevat het het aantal neuronen dat gelijk is aan het aantal klassen. Voor binaire classificatie bevat het één neuron.
De ingangen worden vermenigvuldigd met gewichten en vervolgens ingevoerd in de volgende verborgen laag. Bias wordt ook gegeven als input samen met gewogen inputs. De gewogen som wordt doorgegeven door een niet-lineaire functie genaamd activeringsfunctie.
Implementatie voorbeeld
Hier is het implementatievoorbeeld dat hieronder wordt genoemd
Bibliotheken installatie
Er zijn veel ingebouwde bibliotheken voor de implementatie van kunstmatige neurale netwerken in verschillende programmeertalen. Hier zullen we praten over twee van de beroemde bibliotheken tensorflow en Keras met behulp van python als de programmeertaal voor de implementatie van neurale netwerken. Keras is een hoger niveau api gebouwd op tensorflow of theano als backend. Het is veel eenvoudiger voor implementatie. U kunt elk van de bibliotheken voor uw model kiezen. Er zijn enkele anderen ook beschikbaar zoals PyTorch, theano, Caffe en nog veel meer.
Voer de volgende opdracht uit om de tensorflow / Keras te installeren met behulp van pip:
pip install tensorflow
pip install Keras
Als alternatief kan het worden geïnstalleerd met behulp van het conda-commando,
conda install -c conda-forge tensorflow
conda install -c conda-forge keras
Implementatie
Hier zullen we het hebben over Keras voor het genereren van de diepe leermodellen. Het is een open-source Python deep learning-bibliotheek.
- Importeer de beschikbare MNIST-gegevensset. MNIST is de dataset van handgeschreven cijfers van Engelse cijfers.
from tensorflow.examples.tutorials.mnist import input_data
train_images = mnist.train.images.reshape(mnist.train.images.shape(0), image_rows, image_cols, 1)
test_images = mnist.test.images.reshape(mnist.test.images.shape(0), image_rows, image_cols, 1)
- Initialiseer de parameters en hyperparameters die nodig zijn voor het model.
- Initialiseer vervolgens het deep learning-model.
model = Sequential()
- Voeg een convolutielaag, een activeringslaag en een max-poolinglaag toe voor elk van de convolutielagen die we toevoegen tussen de invoer- en uitvoerlaag (verborgen lagen). Hier voegen we twee convolutielagen toe.
model.add(Convolution2D(num_filters, conv_kernel_size(0), conv_kernel_size(1), border_mode='valid', input_shape=imag_shape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=max_pool_size))
- Verschillende activeringsfuncties kunnen worden gebruikt volgens het probleem. Enkele veel voorkomende activeringsfuncties zijn relu-activering, tanh-activering lek relu en vele andere.
- Dan komt een volledig verbonden laag vóór de dichte laag. Ze compileren de gegevens die door vorige lagen zijn geëxtraheerd om de uiteindelijke uitvoer te vormen.
- De dimensie van de uitvoerlaag is afhankelijk van het aantal klassen. De activeringsfuncties die worden gebruikt voor de uitvoerlaag zijn over het algemeen sigmoïde activering voor binaire classificatie en softmax-activering voor multi-class classificatie.
model.add(Dense(num_classes))
model.add(Activation('softmax'))
De volledige code voor het diepe convolutionele neurale netwerk voor de classificatie van MNIST-gegevens is als volgt.
from tensorflow.examples.tutorials.mnist import input_data
from keras.models import Sequential from keras.layers import Dense, Dropout, Activation, Flatten from keras.layers import Convolution2D, MaxPooling2D
# we use TF helper function to pull down the data from the MNIST site mnist_data = input_data.read_data_sets("MNIST_data/", one_hot=True)
img_rows = 28
img_cols = 28
# Reshape training and test images to 28x28x1
train_images = mnist_data.train.images.reshape(mnist_data.train.images.shape(0), img_rows, img_cols, 1)
test_images = mnist_data.test.images.reshape(mnist_data.test.images.shape(0), img_rows, img_cols, 1)
num_of_filters = 32 # No. of conv filters maxPoolSize = (2, 2) # shape of max_pool convKrnSize = (3, 3) # conv kernel shape imgShape = (28, 28, 1) num_of_classes = 10
dropProb = 0.5
model = Sequential()
# define layers in NN
# Define 1st convolution layer.
model.add(Convolution2D(num_of_filters, convKrnSize(0), convKrnSize(1), border_mode='valid', input_shape=imgShape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=maxPoolSize))
# 2nd Convolution Layer
model.add(Convolution2D(num_of_filters, convKrnSize(0), convKrnSize(1))) model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=maxPoolSize))
#Fully Connected Layer model.add(Flatten())
model.add(Dense(128)) #Fully connected layer in Keras model.add(Activation('relu'))
# Dropout some neurons to reduce overfitting model.add(Dropout(dropProb))
#Readout Layer model.add(Dense(num_of_classes))
model.add(Activation('softmax'))
# Compile the model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=('accuracy'))
# Training settings batch_size = 128
num_of_epoch = 2
# fit the training data to the model.
model.fit(train_images, mnist_data.train.labels, batch_size=batch_size,
nb_epoch=num_of_epoch, verbose=1, validation_data=(test_images, mnist_data.test.labels))
# predict the test_data using the model
test_labels_predicted = model.predict_classes(test_images)
# To get the predicted labels of all test images for i in range(len(test_images)):
print ("Image () -> Label ()".format(i+1, test_labels_predicted(0)))
Opleiding
De training van het model ziet eruit als
Conclusie - Implementatie van neurale netwerken
Neurale netwerken bieden een gemakkelijke manier voor classificatie- of regressieproblemen bij machinaal leren wanneer de functieruimte van de monsters erg groot is, voornamelijk voor grote afbeeldingen of andere multimedia of signalen.
Aanbevolen artikelen
Dit is een handleiding voor de implementatie van neurale netwerken. Hier bespreken we de architectuur en implementatie van neurale netwerken met een trainingsmodel en voorbeeldcode. U kunt ook het volgende artikel bekijken voor meer informatie -
- Classificatie van neuraal netwerk
- Wat is neurale netwerken?
- Convolutionele neurale netwerken
- Neurale netwerkalgoritmen
- 2D-afbeeldingen in Java