Oversigt over implementering af neurale netværk

Kunstige neurale netværk er inspireret af biologiske neurale netværk. Neural Networks hjælper med at løse problemerne uden at være programmeret med de problemspecifikke regler og betingelser. Det er generiske modeller med de fleste af de komplekse matematiske beregninger som BlackBox. De forskellige typer neurale netværk er som Convolution Neural Network, Recurrent Neural Network, Feedforward Neural Network, Multilayer perceptron og mange andre. I dette emne er vi ogin om at lære om implementering af neurale netværk.

Arkitekturen af ​​neurale netværk

Der er 3 lag hovedsageligt i neurale netværk.

  • Inputlag
  • Skjulte lag
  • Outputlag

1. Inputlag: Inputlaget indeholder neuroner til input af funktioner. Der tilføjes også en bias til inputlaget ud over funktionerne. Så hvis der er n funktioner, så indeholder inputlaget n + 1 neuroner.

2. Skjult lag: De skjulte lag er de mellemliggende lag mellem input- og output-lagene. Der kan være et vilkårligt antal skjulte lag. Netværket med mere end et skjult lag kaldes dybe neurale netværk. Neuronerne i det skjulte lag får input fra inputlaget, og de giver output til outputlaget.

3. Outputlag: Outputlaget indeholder antallet af neuroner baseret på antallet af outputklasser. Hvis det er et klassifikationsproblem i flere klasser, indeholder det antallet af neuroner lig med antallet af klasser. Til binær klassificering indeholder den en neuron.

Indgangene ganges med vægte og føres derefter ind i det næste skjulte lag. Bias gives også som input sammen med vægtede input. Den vægtede sum føres gennem en ikke-lineær funktion kaldet aktiveringsfunktion.

Implementeringseksempel

Her er implementeringseksemplet nævnt nedenfor

Biblioteker Installation

Der er mange indbyggede biblioteker til implementering af kunstige neurale netværk på forskellige programmeringssprog. Her vil vi tale om to af de berømte biblioteker tensorflow og Keras, der bruger python som programmeringssprog til implementering af neurale netværk. Keras er en højere niveau api bygger på tensorflow eller theano som backend. Det er meget lettere at implementere. Du kan vælge et hvilket som helst af bibliotekerne til din model. Der er nogle andre også tilgængelige som PyTorch, theano, Caffe og mange flere.

For at installere tensorflow / Keras ved hjælp af pip skal du køre følgende kommando:

pip install tensorflow
pip install Keras

Alternativt kan det installeres ved hjælp af conda-kommando,

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

Implementering

Her vil vi tale om Keras til generering af modeller for dyb læring. Det er et open source-bibliotek med dyb læring af Python.

  • Importer det tilgængelige MNIST-datasæt. MNIST er datasættet med håndskrevne tal for engelske cifre.

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)

  • Initialiser de nødvendige parametre og hyperparametre til modellen.
  • Initialiser derefter den dybe læringsmodel.

model = Sequential()

  • Tilføj konvolutionslag, aktiveringslag og max-poolinglag for hvert af konvolutionslagene, som vi tilføjer mellem input og output lag (skjulte lag). Her tilføjer vi to konvolutionslag.

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

  • Forskellig aktiveringsfunktion kan bruges i henhold til problemet. Nogle almindelige aktiveringsfunktioner er relu-aktivering, tanh-aktivering lækkende relu og mange andre.
  • Derefter kommer et fuldt tilsluttet lag før det tætte lag. De samler de data, der er uddraget med tidligere lag, for at danne den endelige output.
  • Udgangslagets dimension afhænger af antallet af klasser. De aktiveringsfunktioner, der bruges til outputlaget, er generelt sigmoidaktivering til binær klassificering og softmaxaktivering til klasseklassificering.

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

Den komplette kode for det dybe indviklede neurale netværk til klassificering af MNIST-data er som nedenfor.

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

Uddannelse

Træningen af ​​modellen ser ud,

Konklusion - Implementering af neurale netværk

Neurale netværk giver en nem måde at klassificere eller regressionsproblemer i maskinlæring, når prøveeksemplets funktionsområde er meget stort, hovedsageligt til store billeder eller anden multimedia eller signaler.

Anbefalede artikler

Dette er en guide til implementering af neurale netværk. Her diskuterer vi arkitektur og implementering af neurale netværk med en træningsmodel og prøvekode. Du kan også se på den følgende artikel for at lære mere -

  1. Klassificering af neuralt netværk
  2. Hvad er neurale netværk?
  3. Konvolutional neurale netværk
  4. Neurale netværksalgoritmer
  5. 2D-grafik i Java

Kategori:

Big Data