Artificial Neural Network Tutorial med TensorFlow ANN-eksempler

Hva er kunstig nevrale nettverk?

An Kunstig nevralt nettverk (ANN) er et datasystem inspirert av biologiske nevrale nettverk for å lage kunstige hjerner basert på samlingen av tilkoblede enheter kalt kunstige nevroner. Den er designet for å analysere og behandle informasjon som mennesker. Artificial Neural Network har selvlærende evner for å gi bedre resultater ettersom mer data er tilgjengelig.

Et kunstig nevralt nettverk (ANN) er sammensatt av fire hovedobjekter:

• Lag: all læring skjer i lagene. Det er 3 lag 1) Inngang 2) Skjult og 3) Utgang
• Funksjon og etikett: Inndata til nettverket (funksjoner) og utdata fra nettverket (etiketter)
• Tapsfunksjon: Beregning som brukes til å estimere ytelsen til læringsfasen
• Optimizer: Forbedre læringen ved å oppdatere kunnskapen i nettverket

Et nevralt nettverk vil ta inndataene og skyve dem inn i et ensemble av lag. Nettverket må evaluere ytelsen med en tapsfunksjon. Tapsfunksjonen gir nettverket en idé om veien det må gå før det mestrer kunnskapen. Nettverket må forbedre sin kunnskap ved hjelp av en optimizer.

Hvis du tar en titt på figuren ovenfor, vil du forstå den underliggende mekanismen.

Programmet tar noen inngangsverdier og skyver dem inn i to fullstendig sammenkoblede lag. Tenk deg at du har et matematisk problem, det første du gjør er å lese det tilsvarende kapittelet for å løse problemet. Du bruker din nye kunnskap for å løse problemet. Det er stor sjanse for at du ikke scorer veldig bra. Det er det samme for et nettverk. Første gang den ser dataene og gjør en prediksjon, vil den ikke samsvare perfekt med de faktiske dataene.

For å forbedre kunnskapen bruker nettverket en optimizer. I vår analogi kan en optimizer betraktes som å lese kapittelet på nytt. Du får ny innsikt/lærdom ved å lese på nytt. På samme måte bruker nettverket optimizeren, oppdaterer kunnskapen sin og tester den nye kunnskapen for å sjekke hvor mye det fortsatt trenger å lære. Programmet vil gjenta dette trinnet til det gir lavest mulig feil.

I vår matematikkoppgaveanalogi betyr det at du leser lærebokkapittelet mange ganger til du forstår kursinnholdet grundig. Selv etter å ha lest flere ganger, hvis du fortsetter å gjøre en feil, betyr det at du nådde kunnskapskapasiteten med det gjeldende materialet. Du må bruke en annen lærebok eller teste en annen metode for å forbedre poengsummen din. For et nevralt nettverk er det den samme prosessen. Hvis feilen er langt fra 100 %, men kurven er flat, betyr det med gjeldende arkitektur; den kan ikke lære noe annet. Nettverket må optimaliseres bedre for å forbedre kunnskapen.

Nevrale nettverket Architecture

Det kunstige nevrale nettverket Architecture består av følgende komponenter:

• Lag
• Aktiveringsfunksjon
• Tapsfunksjon
• Optimizer

Lag

Et lag er der all læring finner sted. Inne i et lag er det en uendelig mengde vekter (nevroner). Et typisk nevralt nettverk blir ofte behandlet av tett sammenkoblede lag (også kalt fullt sammenkoblede lag). Det betyr at alle inngangene er koblet til utgangen.

Et typisk nevralt nettverk tar en vektor av input og en skalar som inneholder etikettene. Det mest komfortable oppsettet er en binær klassifisering med bare to klasser: 0 og 1.

Nettverket tar en inngang, sender den til alle tilkoblede noder og beregner signalet med en aktivering funksjon.

Figuren ovenfor plotter denne ideen. Det første laget er inngangsverdiene for det andre laget, kalt det skjulte laget, mottar vektet input fra forrige lag

1. Den første noden er inngangsverdiene
2. Nevronet dekomponeres i inngangsdelen og aktiveringsfunksjonen. Den venstre delen mottar alle input fra forrige lag. Den høyre delen er summen av inngangen som går over til en aktiveringsfunksjon.
3. Utdataverdi beregnet fra de skjulte lagene og brukt til å lage en prediksjon. For klassifisering er det lik antall klasser. For regresjon er kun én verdi forutsagt.

Aktiveringsfunksjon

Aktiveringsfunksjonen til en node definerer utgangen gitt et sett med innganger. Du trenger en aktiveringsfunksjon for å la nettverket lære ikke-lineært mønster. En vanlig aktiveringsfunksjon er en Relu, Rettet lineær enhet. Funksjonen gir en null for alle negative verdier.

De andre aktiveringsfunksjonene er:

• Stykkevis lineær
• Sigmoid
• Tanh
• Lekk Relu

Den kritiske beslutningen å ta når man bygger et nevralt nettverk er:

• Hvor mange lag i det nevrale nettverket
• Hvor mange skjulte enheter for hvert lag

Nevrale nettverk med mange lag og skjulte enheter kan lære en kompleks representasjon av dataene, men det gjør nettverkets beregninger svært kostbare.

Tapsfunksjon

Etter at du har definert de skjulte lagene og aktiveringsfunksjonen, må du spesifisere tapsfunksjonen og optimalisereren.

For binær klassifisering er det vanlig praksis å bruke en binær kryssentropitapsfunksjon. I den lineære regresjonen bruker du den gjennomsnittlige kvadratfeilen.

Tapsfunksjonen er en viktig beregning for å estimere ytelsen til optimalisereren. Under opplæringen vil denne beregningen bli minimert. Du må velge denne mengden nøye avhengig av typen problem du har å gjøre med.

Optimizer

Tapsfunksjonen er et mål på modellens ytelse. Optimalisatoren vil bidra til å forbedre vekten til nettverket for å redusere tapet. Det er forskjellige optimerere tilgjengelig, men den vanligste er Stokastisk Gradient Descent.

De konvensjonelle optimererne er:

• Momentum optimalisering,
• Nesterov akselerert gradient,
• AdaGrad,
• Adam optimering

Begrensninger for nevrale nettverk

Følgende er begrensningene til Neural Network:

overfitting

Et vanlig problem med det komplekse nevrale nettet er vanskelighetene med å generalisere usynlige data. Et nevralt nettverk med mange vekter kan identifisere spesifikke detaljer i togsettet veldig bra, men fører ofte til overfitting. Hvis dataene er ubalanserte innenfor grupper (dvs. ikke nok data tilgjengelig i noen grupper), vil nettverket lære veldig godt under treningen, men vil ikke ha evnen til å generalisere et slikt mønster til data som ikke er sett før.

Det er en avveining i maskinlæring mellom optimalisering og generalisering.

Optimaliser en modell krever for å finne de beste parameterne som minimerer tapet av treningssettet.

Generalisering forteller imidlertid hvordan modellen oppfører seg for usynlige data.

For å forhindre at modellen fanger spesifikke detaljer eller uønskede mønstre av treningsdataene, kan du bruke forskjellige teknikker. Den beste metoden er å ha et balansert datasett med tilstrekkelig mengde data. Kunsten å redusere overfitting kalles regularisering. La oss se på noen konvensjonelle teknikker.

Nettverksstørrelse

Et nevralt nettverk med for mange lag og skjulte enheter er kjent for å være svært sofistikert. En enkel måte å redusere kompleksiteten til modellen er å redusere størrelsen. Det er ingen beste praksis for å definere antall lag. Du må starte med en liten mengde lag og øke størrelsen til du finner modellen overfitt.

Vektregulering

En standard teknikk for å forhindre overtilpasning er å legge begrensninger på vekten til nettverket. Begrensningen tvinger størrelsen på nettverket til å ta bare små verdier. Begrensningen legges til tapsfunksjonen til feilen. Det er to typer regularisering:

L1: Lasso: Kostnaden er proporsjonal med den absolutte verdien av vektkoeffisientene

L2: Ridge: Kostnaden er proporsjonal med kvadratet av verdien av vektkoeffisientene

dropout

Frafall er en merkelig, men nyttig teknikk. Et nettverk med frafall betyr at noen vekter vil bli tilfeldig satt til null. Tenk deg at du har en rekke vekter [0.1, 1.7, 0.7, -0.9]. Hvis det nevrale nettverket har et frafall, vil det bli [0.1, 0, 0, -0.9] med tilfeldig fordelt 0. Parameteren som styrer frafallet er frafallsraten. Satsen definerer hvor mange vekter som skal settes til null. Å ha en rate mellom 0.2 og 0.5 er vanlig.

Eksempel på nevralt nettverk i TensorFlow

La oss se et kunstig nevralt nettverk i aksjon på hvordan et nevralt nettverk fungerer for et typisk klassifiseringsproblem. Det er to innganger, x1 og x2 med en tilfeldig verdi. Utgangen er en binær klasse. Målet er å klassifisere etiketten basert på de to funksjonene. For å utføre denne oppgaven er den nevrale nettverksarkitekturen definert som følgende:

• To skjulte lag
  • Det første laget har fire fullstendig sammenkoblede nevroner
  • Andre lag har to fullstendig sammenkoblede nevroner
• Aktiveringsfunksjonen er en Relu
• Legg til en L2-regularisering med en læringsrate på 0.003

Nettverket vil optimalisere vekten i løpet av 180 epoker med en batchstørrelse på 10. I ANN-eksempelvideoen nedenfor kan du se hvordan vektene utvikler seg over tid og hvordan nettverket forbedrer klassifiseringskartet.ping.

Først av alt tildeler nettverket tilfeldige verdier til alle vektene.

• Med de tilfeldige vektene, dvs. uten optimalisering, er utgangstapet 0.453. Bildet nedenfor representerer nettverket med forskjellige farger.
• Generelt representerer den oransje fargen negative verdier mens de blå fargene viser de positive verdiene.
• Datapunktene har samme representasjon; de blå er de positive etikettene og den oransje de negative etikettene.

Inne i det andre skjulte laget er linjene farget etter tegnet til vektene. De oransje linjene tildeler negative vekter og den blå en positiv vekt

Som du kan se, i utdatakartetping, nettverket gjør ganske mange feil. La oss se hvordan nettverket oppfører seg etter optimalisering.

Bildet av ANN-eksemplet nedenfor viser resultatene av det optimaliserte nettverket. Først av alt legger du merke til at nettverket har lært hvordan man klassifiserer datapunktet. Du kan se fra bildet før; startvekten var -0.43 mens den etter optimalisering resulterer i en vekt på -0.95.

Ideen kan generaliseres for nettverk med mer skjulte lag og nevroner. Du kan leke i link.

Hvordan trene et nevralt nettverk med TensorFlow

Her er trinn-for-trinn-prosessen for hvordan du trener et nevralt nettverk med TensorFlow ANN ved å bruke API-ens estimator DNNClassifier.

Vi vil bruke MNIST-datasettet til å trene ditt første nevrale nettverk. Trene et nevralt nettverk med tensorflow er ikke veldig komplisert. Forbehandlingstrinnet ser nøyaktig det samme ut som i de forrige veiledningene. Du vil fortsette som følger:

• Trinn 1: Importer dataene
• Trinn 2: Transformer dataene
• Trinn 3: Konstruer tensoren
• Trinn 4: Bygg modellen
• Trinn 5: Tren og evaluer modellen
• Trinn 6: Forbedre modellen

Trinn 1) Importer dataene

Først av alt må du importere det nødvendige biblioteket. Du kan importere MNIST-datasettet ved å bruke scikit learning som vist i TensorFlow Neural Network-eksemplet nedenfor.

MNIST-datasettet er det ofte brukte datasettet for å teste nye teknikker eller algoritmer. Dette datasettet er en samling av 28×28 piksler med et håndskrevet siffer fra 0 til 9. Foreløpig er den laveste feilen på testen 0.27 prosent med en komité på 7 konvolusjonelle nevrale nettverk.

import numpy as np
import tensorflow as tf
np.random.seed(1337)

Du kan laste ned scikit learning midlertidig på denne adressen. Kopier og lim inn datasettet i en praktisk mappe. For å importere dataene til python kan du bruke fetch_mldata fra scikit learning. Lim inn filbanen inne i fetch_mldata for å hente dataene.

from sklearn.datasets import fetch_mldata
mnist = fetch_mldata(' /Users/Thomas/Dropbox/Learning/Upwork/tuto_TF/data/mldata/MNIST original')
print(mnist.data.shape)
print(mnist.target.shape)

Etter det importerer du dataene og får formen til begge datasettene.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )

Trinn 2) Transformer dataene

I den forrige opplæringen lærte du at du må transformere dataene for å begrense effekten av uteliggere. I denne Neural Networks-opplæringen vil du transformere dataene ved å bruke min-max scaler. Formelen er:

(X-min_x)/(max_x - min_x)

Scikit lærer har allerede en funksjon for det: MinMaxScaler()

## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))

Trinn 3) Konstruer tensoren

Du er nå kjent med måten å lage tensor i Tensorflow. Du kan konvertere togsettet til en numerisk kolonne.

feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]

Trinn 4) Bygg modellen

Arkitekturen til det nevrale nettverket inneholder 2 skjulte lag med 300 enheter for det første laget og 100 enheter for det andre. Vi bruker disse verdiene basert på vår egen erfaring. Du kan justere disse verdiene og se hvordan det påvirker nøyaktigheten til nettverket.

For å bygge modellen bruker du estimatoren DNNClassifier. Du kan legge til antall lag i feature_columns-argumentene. Du må sette antall klasser til 10 da det er ti klasser i treningssettet. Du er allerede kjent med syntaksen til estimatorobjektet. Argumentene inneholder kolonner, antall klasser og model_dir er nøyaktig de samme som i den forrige opplæringen. Det nye argumentet hidden_unit kontrollerer antall lag og hvor mange noder som skal kobles til det nevrale nettverket. I koden nedenfor er det to skjulte lag med et første som forbinder 300 noder og det andre med 100 noder.

For å bygge estimatoren, bruk tf.estimator.DNNClassifier med følgende parametere:

• feature_columns: Definer kolonnene som skal brukes i nettverket
• skjulte_enheter: Definer antall skjulte nevroner
• n_classes: Definer antall klasser som skal forutsi
• model_dir: Definer banen til TensorBoard

estimator = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100], 
    n_classes=10, 
    model_dir = '/train/DNN')

Trinn 5) Tren og evaluer modellen

Du kan bruke numpy-metoden til å trene modellen og evaluere den

# Train the estimator
train_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=50,
    shuffle=False,
    num_epochs=None)
estimator.train(input_fn = train_input,steps=1000) 
eval_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test, 
    shuffle=False,
    batch_size=X_test_scaled.shape[0],
    num_epochs=1)
estimator.evaluate(eval_input,steps=None) 

Utgang:

{'accuracy': 0.9637143,
 'average_loss': 0.12014342,
 'loss': 1682.0079,
 'global_step': 1000}

Den nåværende arkitekturen fører til en nøyaktighet på evalueringssettet på 96 prosent.

Trinn 6) Forbedre modellen

Du kan prøve å forbedre modellen ved å legge til regulariseringsparametere.

Vi vil bruke en Adam optimizer med en frafallsrate på 0.3, L1 av X og L2 av y. I TensorFlow Neural Network kan du kontrollere optimalisereren ved å bruke objekttoget etter navnet på optimalisereren. tensorflow er en innebygd API for Proximal AdaGrad optimizer.

For å legge til regularisering til det dype nevrale nettverket, kan du bruke tf.train.ProximalAdagradOptimizer med følgende parameter

• Læringsrate: learning_rate
• L1-regularisering: l1_regularization_styrke
• L2-regularisering: l2_regularization_styrke

estimator_imp = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100],
    dropout=0.3, 
    n_classes = 10,
    optimizer=tf.train.ProximalAdagradOptimizer(
      learning_rate=0.01,
      l1_regularization_strength=0.01, 
      l2_regularization_strength=0.01
    ),
    model_dir = '/train/DNN1')
estimator_imp.train(input_fn = train_input,steps=1000) 
estimator_imp.evaluate(eval_input,steps=None) 

Utgang:

{'accuracy': 0.95057142,
 'average_loss': 0.17318928,
 'loss': 2424.6499,
 'global_step': 2000}

Verdiene valgt for å redusere overtilpasningen forbedret ikke modellens nøyaktighet. Din første modell hadde en nøyaktighet på 96 %, mens modellen med L2-regularizer har en nøyaktighet på 95 %. Du kan prøve med forskjellige verdier og se hvordan det påvirker nøyaktigheten.

Sammendrag

I denne opplæringen lærer du hvordan du bygger et nevralt nettverk. Et nevralt nettverk krever:

• Antall skjulte lag
• Antall fullstendig tilkoblede noder
• Aktiveringsfunksjon
• Optimizer
• Antall klasser

I TensorFlow ANN kan du trene et nevralt nettverk for klassifiseringsproblem med:

• tf.estimator.DNNClassifier

Estimatoren krever å spesifisere:

• feature_columns=feature_columns,
• skjulte_enheter=[300, 100]
• n_classes=10
• model_dir

Du kan forbedre modellen ved å bruke forskjellige optimerere. I denne opplæringen lærte du hvordan du bruker Adam Grad optimizer med en læringshastighet og legger til en kontroll for å forhindre overtilpasning.