Tutorial til kunstigt neuralt netværk med TensorFlow ANN-eksempler

Hvad er kunstigt neuralt netværk?

An Kunstigt neuralt netværk (ANN) er et computersystem inspireret af biologiske neurale netværk til at skabe kunstige hjerner baseret på samlingen af ​​forbundne enheder kaldet kunstige neuroner. Det er designet til at analysere og behandle information som mennesker. Artificial Neural Network har selvlærende evner til at producere bedre resultater, efterhånden som flere data er tilgængelige.

Et kunstigt neuralt netværk (ANN) er sammensat af fire hovedobjekter:

• Lag: al læring foregår i lagene. Der er 3 lag 1) Input 2) Skjult og 3) Output
• Funktion og etiket: Input data til netværket (funktioner) og output fra netværket (etiketter)
• Tabsfunktion: Metrik, der bruges til at estimere læringsfasens ydeevne
• Optimizer: Forbedre læringen ved at opdatere viden i netværket

Et neuralt netværk vil tage inputdataene og skubbe dem ind i et ensemble af lag. Netværket skal evaluere sin ydeevne med en tabsfunktion. Tabsfunktionen giver netværket en idé om den vej, det skal gå, før det mestrer viden. Netværket skal forbedre sin viden ved hjælp af en optimizer.

Hvis du tager et kig på figuren ovenfor, vil du forstå den underliggende mekanisme.

Programmet tager nogle inputværdier og skubber dem ind i to fuldt forbundne lag. Forestil dig, at du har et matematisk problem, det første du gør er at læse det tilsvarende kapitel for at løse problemet. Du anvender din nye viden til at løse problemet. Der er en stor chance for, at du ikke scorer særlig godt. Det er det samme for et netværk. Første gang den ser dataene og foretager en forudsigelse, vil den ikke matche perfekt med de faktiske data.

For at forbedre sin viden bruger netværket en optimizer. I vores analogi kan en optimering opfattes som at genlæse kapitlet. Du får ny indsigt/lære ved at læse igen. På samme måde bruger netværket optimeringsværktøjet, opdaterer sin viden og tester sin nye viden for at tjekke, hvor meget det stadig mangler at lære. Programmet vil gentage dette trin, indtil det giver den lavest mulige fejl.

I vores matematiske problemanalogi betyder det, at du læser lærebogskapitlet mange gange, indtil du forstår kursusindholdet grundigt. Selv efter at have læst flere gange, hvis du bliver ved med at lave en fejl, betyder det, at du har nået videnskapaciteten med det aktuelle materiale. Du skal bruge en anden lærebog eller teste en anden metode for at forbedre din score. For et neuralt netværk er det den samme proces. Hvis fejlen er langt fra 100%, men kurven er flad, betyder det med den nuværende arkitektur; den kan ikke lære andet. Netværket skal optimeres bedre for at forbedre viden.

Neural Network Architecture

Det kunstige neurale netværk ArchiTecture består af følgende komponenter:

• Lag
• Aktivering funktion
• Tabsfunktion
• Optimizer

Lag

Et lag er der, hvor al læring finder sted. Inde i et lag er der en uendelig mængde vægte (neuroner). Et typisk neuralt netværk behandles ofte af tæt forbundne lag (også kaldet fuldt forbundne lag). Det betyder, at alle indgange er forbundet til udgangen.

Et typisk neuralt netværk tager en vektor af input og en skalar, der indeholder etiketterne. Den mest komfortable opsætning er en binær klassifikation med kun to klasser: 0 og 1.

Netværket tager et input, sender det til alle tilsluttede noder og beregner signalet med en aktivering funktion.

Figuren ovenfor viser denne idé. Det første lag er inputværdierne for det andet lag, kaldet det skjulte lag, modtager det vægtede input fra det forrige lag

1. Den første node er inputværdierne
2. Neuronet nedbrydes i inputdelen og aktiveringsfunktionen. Den venstre del modtager alle input fra det forrige lag. Den højre del er summen af ​​input, der går over i en aktiveringsfunktion.
3. Outputværdi beregnet ud fra de skjulte lag og brugt til at lave en forudsigelse. For klassificering er det lig med antallet af klasse. For regression forudsiges kun én værdi.

Aktivering funktion

Aktiveringsfunktionen af ​​en node definerer output givet et sæt af input. Du skal bruge en aktiveringsfunktion for at tillade netværket at lære ikke-lineært mønster. En almindelig aktiveringsfunktion er en Relu, ensrettet lineær enhed. Funktionen giver et nul for alle negative værdier.

De andre aktiveringsfunktioner er:

• Stykkevis lineær
• Sigmoid
• Tanh
• Utæt Relu

Den kritiske beslutning at tage, når man bygger et neuralt netværk, er:

• Hvor mange lag i det neurale netværk
• Hvor mange skjulte enheder for hvert lag

Neurale netværk med masser af lag og skjulte enheder kan lære en kompleks repræsentation af dataene, men det gør netværkets beregning meget dyr.

Tabsfunktion

Når du har defineret de skjulte lag og aktiveringsfunktionen, skal du angive tabsfunktionen og optimeringsfunktionen.

Til binær klassificering er det almindelig praksis at bruge en binær krydsentropitabsfunktion. I den lineære regression bruger du den gennemsnitlige kvadratiske fejl.

Tabsfunktionen er en vigtig metrik til at estimere optimeringsfunktionens ydeevne. I løbet af træningen vil denne metrik blive minimeret. Du skal vælge denne mængde omhyggeligt afhængigt af den type problem, du har at gøre med.

Optimizer

Tabsfunktionen er et mål for modellens ydeevne. Optimizeren hjælper med at forbedre netværkets vægte for at mindske tabet. Der findes forskellige optimeringsværktøjer, men den mest almindelige er Stokastisk Gradient Descent.

De konventionelle optimeringsværktøjer er:

• Momentum optimering,
• Nesterov Accelereret Gradient,
• AdaGrad,
• Adam optimering

Begrænsninger af neurale netværk

Følgende er begrænsningerne ved neuralt netværk:

overfitting

Et almindeligt problem med det komplekse neurale net er vanskelighederne med at generalisere usete data. Et neuralt netværk med masser af vægte kan identificere specifikke detaljer i togsættet meget godt, men fører ofte til overfitting. Hvis dataene er ubalancerede inden for grupper (dvs. ikke nok data tilgængelige i nogle grupper), vil netværket lære meget godt under træningen, men vil ikke have evnen til at generalisere et sådant mønster til aldrig set-før-data.

Der er en afvejning i maskinlæring mellem optimering og generalisering.

Optimer en model kræver for at finde de bedste parametre, der minimerer tabet af træningssættet.

Generalisering fortæller dog, hvordan modellen opfører sig for usete data.

For at forhindre modellen i at fange specifikke detaljer eller uønskede mønstre af træningsdataene, kan du bruge forskellige teknikker. Den bedste metode er at have et afbalanceret datasæt med tilstrækkelig mængde data. Kunsten at reducere overfitting kaldes legaliseringen. Lad os gennemgå nogle konventionelle teknikker.

Netværksstørrelse

Et neuralt netværk med for mange lag og skjulte enheder er kendt for at være meget sofistikeret. En ligetil måde at reducere kompleksiteten af ​​modellen på er at reducere dens størrelse. Der er ingen bedste praksis til at definere antallet af lag. Du skal starte med en lille mængde lag og øge dens størrelse, indtil du finder modellen overfit.

Vægtregulering

En standardteknik til at forhindre overfitting er at tilføje begrænsninger til netværkets vægte. Begrænsningen tvinger netværkets størrelse til kun at tage små værdier. Begrænsningen føjes til tabsfunktionen for fejlen. Der er to former for regulering:

L1: Lasso: Omkostningerne er proportionale med den absolutte værdi af vægtkoefficienterne

L2: Ridge: Omkostningerne er proportionale med kvadratet af værdien af ​​vægtkoefficienterne

Droppe ud

Frafald er en mærkelig, men nyttig teknik. Et netværk med frafald betyder, at nogle vægte vil blive sat tilfældigt til nul. Forestil dig, at du har en række vægte [0.1, 1.7, 0.7, -0.9]. Hvis det neurale netværk har et frafald, bliver det [0.1, 0, 0, -0.9] med tilfældigt fordelt 0. Den parameter, der styrer frafaldet, er frafaldsraten. Satsen definerer, hvor mange vægte der skal sættes til nul. At have en rate mellem 0.2 og 0.5 er almindeligt.

Eksempel på neuralt netværk i TensorFlow

Lad os se et kunstigt neuralt netværks eksempel i aktion på, hvordan et neuralt netværk fungerer for et typisk klassifikationsproblem. Der er to indgange, x1 og x2 med en tilfældig værdi. Outputtet er en binær klasse. Målet er at klassificere etiketten ud fra de to funktioner. For at udføre denne opgave er den neurale netværksarkitektur defineret som følgende:

• To skjulte lag
  • Første lag har fire fuldt forbundne neuroner
  • Andet lag har to fuldt forbundne neuroner
• Aktiveringsfunktionen er en Relu
• Tilføj en L2-regularisering med en indlæringshastighed på 0.003

Netværket vil optimere vægten i løbet af 180 epoker med en batchstørrelse på 10. I ANN eksempelvideoen nedenfor kan du se, hvordan vægtene udvikler sig, og hvordan netværket forbedrer klassifikationskortlægningen.

Først og fremmest tildeler netværket tilfældige værdier til alle vægtene.

• Med de tilfældige vægte, dvs. uden optimering, er outputtabet 0.453. Billedet nedenfor repræsenterer netværket med forskellige farver.
• Generelt repræsenterer den orange farve negative værdier, mens de blå farver viser de positive værdier.
• Datapunkterne har samme repræsentation; de blå er de positive etiketter og den orange de negative etiketter.

Inde i det andet skjulte lag er linjerne farvet efter loddets tegn. De orange linjer tildeler negative vægte og den blå en positiv vægt

Som du kan se, laver netværket ret mange fejl i outputmappingen. Lad os se, hvordan netværket opfører sig efter optimering.

Billedet af ANN-eksemplet nedenfor viser resultaterne af det optimerede netværk. Først og fremmest bemærker du, at netværket med succes har lært, hvordan man klassificerer datapunktet. Du kan se af billedet før; startvægten var -0.43, mens den efter optimering resulterer i en vægt på -0.95.

Idéen kan generaliseres til netværk med mere skjulte lag og neuroner. Du kan lege rundt i link.

Sådan træner du et neuralt netværk med TensorFlow

Her er den trinvise proces til, hvordan man træner et neuralt netværk med TensorFlow ANN ved hjælp af API's estimator DNNClassifier.

Vi vil bruge MNIST-datasættet til at træne dit første neurale netværk. Træning af et neuralt netværk med TensorFlow er ikke særlig kompliceret. Forbehandlingstrinnet ser nøjagtigt ud som i de tidligere tutorials. Du vil fortsætte som følger:

• Trin 1: Importer dataene
• Trin 2: Transformer dataene
• Trin 3: Konstruer tensoren
• Trin 4: Byg modellen
• Trin 5: Træn og evaluer modellen
• Trin 6: Forbedre modellen

Trin 1) Importer dataene

Først og fremmest skal du importere det nødvendige bibliotek. Du kan importere MNIST-datasættet ved hjælp af scikit learning som vist i TensorFlow Neural Network-eksemplet nedenfor.

MNIST-datasættet er det almindeligt anvendte datasæt til at teste nye teknikker eller algoritmer. Dette datasæt er en samling af 28×28 pixel billede med et håndskrevet ciffer fra 0 til 9. I øjeblikket er den laveste fejl på testen 0.27 procent med en komité bestående af 7 foldede neurale netværk.

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

Du kan downloade scikit learn midlertidigt på denne adresse. Kopier og indsæt datasættet i en praktisk mappe. For at importere dataene til python kan du bruge fetch_mldata fra scikit learn. Indsæt filstien inde i fetch_mldata for at 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)

Derefter importerer du dataene og får formen på begge datasæt.

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 )

Trin 2) Transformer dataene

I den forrige tutorial lærte du, at du skal transformere dataene for at begrænse effekten af ​​outliers. I denne Neural Networks tutorial vil du transformere dataene ved hjælp af min-max scaler. Formlen er:

(X-min_x)/(max_x - min_x)

Scikit lærer allerede har en funktion til 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))

Trin 3) Konstruer tensoren

Du er nu bekendt med måden at skabe tensor i Tensorflow. Du kan konvertere togsættet til en numerisk kolonne.

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

Trin 4) Byg modellen

Det neurale netværks arkitektur indeholder 2 skjulte lag med 300 enheder til det første lag og 100 enheder til det andet. Vi bruger disse værdier baseret på vores egne erfaringer. Du kan justere disses værdier og se, hvordan det påvirker nøjagtigheden af ​​netværket.

For at bygge modellen bruger du estimatoren DNNClassifier. Du kan tilføje antallet af lag til feature_columns-argumenterne. Du skal indstille antallet af klasser til 10, da der er ti klasser i træningssættet. Du er allerede bekendt med syntaksen for estimatorobjektet. Argumenterne indeholder kolonner, antal klasser og model_dir er præcis de samme som i den forrige tutorial. Det nye argument hidden_unit kontrollerer antallet af lag og hvor mange noder der skal forbindes til det neurale netværk. I koden nedenfor er der to skjulte lag med et første, der forbinder 300 noder og det andet med 100 noder.

For at bygge estimatoren skal du bruge tf.estimator.DNNClassifier med følgende parametre:

• feature_columns: Definer de kolonner, der skal bruges i netværket
• skjulte_enheder: Definer antallet af skjulte neuroner
• n_classes: Definer antallet af klasser, der skal forudsiges
• model_dir: Definer stien til TensorBoard

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

Trin 5) Træn og evaluer modellen

Du kan bruge numpy-metoden til at træne 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) 

Output:

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

Den nuværende arkitektur fører til en nøjagtighed på evalueringssættet på 96 procent.

Trin 6) Forbedre modellen

Du kan prøve at forbedre modellen ved at tilføje regulariseringsparametre.

Vi vil bruge en Adam optimizer med en frafaldsrate på 0.3, L1 af X og L2 af y. I TensorFlow Neural Network kan du styre optimizeren ved hjælp af objekttoget efterfulgt af navnet på optimizeren. TensorFlow er en indbygget API til Proximal AdaGrad optimizer.

For at tilføje regularisering til det dybe neurale netværk kan du bruge tf.train.ProximalAdagradOptimizer med følgende parameter

• Indlæringshastighed: 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) 

Output:

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

De valgte værdier for at reducere overpasningen forbedrede ikke modellens nøjagtighed. Din første model havde en nøjagtighed på 96 %, mens modellen med L2 regularizer har en nøjagtighed på 95 %. Du kan prøve med forskellige værdier og se, hvordan det påvirker nøjagtigheden.

Resumé

I denne tutorial lærer du, hvordan du opbygger et neuralt netværk. Et neuralt netværk kræver:

• Antal skjulte lag
• Antal fuldt tilsluttede knudepunkter
• Aktivering funktion
• Optimizer
• Antal klasser

I TensorFlow ANN kan du træne et neuralt netværk til klassificeringsproblem med:

• tf.estimator.DNNClassifier

Estimatoren kræver at specificere:

• feature_columns=feature_columns,
• skjulte_enheder=[300, 100]
• n_klasser=10
• model_dir

Du kan forbedre modellen ved at bruge forskellige optimeringsværktøjer. I denne tutorial lærte du, hvordan du bruger Adam Grad optimizer med en indlæringshastighed og tilføjer en kontrol for at forhindre overtilpasning.