Oversikt over implementering av nevrale nettverk

Kunstige nevrale nettverk er inspirert av biologiske nevrale nettverk. Neural Networks er med på å løse problemene uten å være programmert med de problemspesifikke regler og betingelser. De er generiske modeller med de fleste av de komplekse matematiske beregningene som BlackBox. De forskjellige typene nevrale nettverk er som Convolution Neural Network, Recurrent Neural Network, Feedforward Neural Network, Multilayer perceptron og mange andre. I dette emnet ønsker vi å lære om implementering av nevrale nettverk.

Arkitekturen av nevrale nettverk

Det er tre lag hovedsakelig i nevrale nettverk.

  • Inputlag
  • Skjulte lag
  • Utgangslag

1. Input Layer: Inngangssjiktet inneholder nevronene for input av funksjoner. Det er også en skjevhet lagt til input-laget i tillegg til funksjonene. Så hvis det er n funksjoner, så inneholder innsatslaget n + 1 nevroner.

2. Skjult lag: De skjulte lagene er mellomlagene mellom input- og output-lagene. Det kan være et hvilket som helst antall skjulte lag. Nettverket med mer enn ett skjult lag kalles dype nevrale nettverk. Nevronene i det skjulte laget får innspill fra innsatslaget, og de gir utdata til utgangssjiktet.

3. Utgangslag: Utgangslaget inneholder antall nevroner basert på antall utgangsklasser. Hvis det er et klasseklassifiseringsproblem i flere klasser, inneholder det antall nevroner som tilsvarer antall klasser. For binær klassifisering inneholder den en nevron.

Inngangene multipliseres med vekter og mates deretter inn i det neste skjulte laget. Skjevhet blir også gitt som input sammen med vektede innganger. Den vektede summen føres gjennom en ikke-lineær funksjon som kalles aktiveringsfunksjon.

Implementeringseksempel

Her er implementeringseksemplet nevnt nedenfor

Bibliotekinstallasjon

Det er mange innebygde biblioteker for implementering av kunstige nevrale nettverk i forskjellige programmeringsspråk. Her vil vi snakke om to av de berømte bibliotekene tensorflow og Keras som bruker python som programmeringsspråk for implementering av nevrale nettverk. Keras er en høyere nivå api bygd på tensorflow eller theano som backend. Det er mye enklere å implementere. Du kan velge hvilket som helst av bibliotekene for din modell. Det er noen andre også tilgjengelig som PyTorch, theano, Caffe og mange flere.

Kjør følgende kommando for å installere tensorflow / Keras ved hjelp av pip:

pip install tensorflow
pip install Keras

Alternativt kan den installeres ved hjelp av conda-kommando,

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

Gjennomføring

Her vil vi snakke om Keras for generasjonen av de dype læringsmodellene. Det er et åpen kildekode-bibliotek med dyp læring.

  • Importer det tilgjengelige MNIST-datasettet. MNIST er datasettet med håndskrevne tall for engelske sifre.

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 parametrene og hyperparametrene som er nødvendige for modellen.
  • Initialiser deretter den dype læringsmodellen.

model = Sequential()

  • Legg til konvolusjonssjikt, aktiveringslag og max-pooling-lag for hvert av konvolusjonssjiktet som vi legger til mellom input- og output-laget (skjulte lag). Her legger vi til to oppløsningslag.

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

  • Ulike aktiveringsfunksjoner kan brukes i henhold til problemet. Noen vanlige aktiveringsfunksjoner er relu-aktivering, tanh-aktivering lekker lekker relu, og mange andre.
  • Så kommer et fullt tilkoblet lag før det tette laget. De samler dataene som er trukket ut av tidligere lag for å danne den endelige utdata.
  • Utføringslagets dimensjon avhenger av antall klasser. Aktiveringsfunksjonene som brukes for utgangssjiktet er generelt sigmoidaktivering for binær klassifisering og softmaxaktivering for klassing i flere klasser.

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

Den komplette koden for det dype, innviklede nevrale nettverket for klassifisering av 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)))

Trening

Opplæringen av modellen ser ut,

Konklusjon - Implementering av nevrale nettverk

Nevrale nettverk gir en enkel måte å klassifisere eller regresjonsproblemer i maskinlæring når funksjonsområdet for prøvene er veldig stort, hovedsakelig for store bilder eller annen multimedia eller signaler.

Anbefalte artikler

Dette er en guide til implementering av nevrale nettverk. Her diskuterer vi arkitekturen og implementeringen av Neural Networks med en treningsmodell og prøvekode. Du kan også se på følgende artikkel for å lære mer -

  1. Klassifisering av nevrale nettverk
  2. Hva er nevrale nettverk?
  3. Konvolusjonelle nevrale nettverk
  4. Nevrale nettverksalgoritmer
  5. 2D-grafikk i Java

Kategori:

Stor Data