Översikt över implementering av nervnätverk

Konstgjorda nervnätverk är inspirerade av biologiska nervnätverk. Neurala nätverk hjälper till att lösa problemen utan att programmeras med de problemspecifika reglerna och villkoren. Det är generiska modeller med de flesta av de komplexa matematiska beräkningarna som BlackBox. De olika typerna av neurala nätverk är som Convolution Neural Network, Recurrent Neural Network, Feedforward Neural Network, Multilayer perceptron och många andra. I det här ämnet vill vi lära oss om implementeringen av nervnätverk.

Arkitekturen för nervnätverk

Det finns tre lager främst i neurala nätverk.

  • Inmatningslager
  • Dolda lager
  • Output Layer

1. Inmatningslager: Inlagret innehåller neuroner för inmatning av funktioner. Det finns också en förspänning som läggs till inmatningsskiktet utöver funktionerna. Så om det finns n funktioner så innehåller ingångsskiktet n + 1 neuroner.

2. Doldt lager : De dolda lagren är mellanlagren mellan ingångs- och utgångsskikten. Det kan finnas valfritt antal dolda lager. Nätverket med mer än ett doldt lager kallas djupa neurala nätverk. Neuronerna i det dolda lagret får input från inmatningsskiktet och de ger utdata till utgångsskiktet.

3. Output Layer: Outputlagret innehåller antalet neuroner baserat på antalet outputklasser. Om det är ett klassificeringsproblem i flera klasser innehåller det antalet neuroner lika med antalet klasser. För binär klassificering innehåller den en neuron.

Ingångarna multipliceras med vikter och matas sedan in i nästa dolda lager. Förspänning ges också som input tillsammans med viktade ingångar. Den vägda summan överförs genom en icke-linjär funktion som kallas aktiveringsfunktion.

Exempel på implementering

Här är implementeringsexemplet som nämns nedan

Bibliotekinstallation

Det finns många inbyggda bibliotek för implementering av konstgjorda neurala nätverk i olika programmeringsspråk. Här kommer vi att prata om två av de berömda biblioteken tensorflow och Keras som använder python som programmeringsspråk för implementering av neurala nätverk. Keras är en högre nivå som bygger på tensorflow eller theano som backend. Det är mycket lättare att genomföra. Du kan välja vilket bibliotek som helst för din modell. Det finns några andra också tillgängliga som PyTorch, theano, Caffe och många fler.

För att installera tensorflow / Keras med pip, kör följande kommando:

pip install tensorflow
pip install Keras

Alternativt kan det installeras med conda-kommando,

conda install -c conda-forge tensorflow
conda install -c conda-forge keras

Genomförande

Här kommer vi att prata om Keras för att skapa de djupa inlärningsmodellerna. Det är ett öppen källkodsbibliotek i Python.

  • Importera det tillgängliga MNIST-datasättet. MNIST är datasatsen för handskrivna siffror för engelska siffror.

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)

  • Initiera parametrarna och hyperparametrarna som är nödvändiga för modellen.
  • Initiera sedan den djupa inlärningsmodellen.

model = Sequential()

  • Lägg till upplösningslager, aktiveringslager och max-poolinglager för var och en av de upplösningslager som vi lägger till mellan ingångs- och utgångsskiktet (dolda lager). Här lägger vi till två upplösningslager.

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

  • Olika aktiveringsfunktioner kan användas enligt problemet. Vissa vanliga aktiveringsfunktioner är relu-aktivering, tanh-aktivering läckande relu och många andra.
  • Sedan kommer ett helt anslutet lager före det täta lagret. De sammanställer de data som extraherats av tidigare lager för att bilda den slutliga utgången.
  • Utmatningslagerdimensionen beror på antalet klasser. Aktiveringsfunktionerna som används för utgångsskiktet är i allmänhet sigmoidaktivering för binär klassificering och softmaxaktivering för flerklassklassificering.

model.add(Dense(num_classes))
model.add(Activation('softmax'))

Den fullständiga koden för det djupa invändiga nervnätverket för klassificering av MNIST-data är som nedan.

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

Träning

Utbildningen av modellen ser ut,

Slutsats - Implementering av nervnätverk

Neurala nätverk är ett enkelt sätt att klassificera eller regressionsproblem i maskininlärning när provernas utrymme är mycket stort, främst för stora bilder eller annan multimedia eller signaler.

Rekommenderade artiklar

Detta är en guide till implementering av nervnätverk. Här diskuterar vi arkitekturen och implementeringen av Neural Networks med en träningsmodell och provkod. Du kan också titta på följande artikel för att lära dig mer -

  1. Klassificering av neuralt nätverk
  2. Vad är nervnätverk?
  3. Konventionella nervnätverk
  4. Neurala nätverksalgoritmer
  5. 2D-grafik i Java

Kategori:

Big Data