Kunstige neurale netværk (ANN) vejledning med TensorFlow

Hvad er kunstigt neuralt netværk?

An Artificial Neural Network (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 på samme måde som mennesker gør. Et kunstigt neuralt netværk har selvlærende egenskaber til at producere bedre resultater, efterhånden som flere data er tilgængelige.

Diagrammet nedenfor tracer én fuld passage gennem et sådant netværk, fra det rå input til optimeringsværktøjet, der korrigerer vægtene.

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

• Lag: Al læring sker i lagene. Der er 3 lag: 1) Input, 2) Skjult og 3) Output
• Funktion og etiket: Inputdata til netværket (funktioner) og output fra netværket (etiketter)
• Tabsfunktion: Metrik brugt til at estimere læringsfasens præstation
• Optimizer: Forbedr læringen ved at opdatere viden i netværket

Et neuralt netværk tager inputdataene og overfører dem til et ensemble af lag. Netværket evaluerer derefter dets ydeevne med en tabsfunktion. Tabsfunktionen giver netværket en idé om den vej, det skal tage, før det mestrer videnen. Netværket forbedrer denne viden ved hjælp af en optimeringsfunktion.

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

Programmet tager nogle inputværdier og samler dem i to fuldt forbundne lag. Forestil dig, at du har et matematikproblem. Det første, du gør, er at læse det tilsvarende kapitel for at løse det. Derefter anvender du din nye viden på problemet. Der er stor sandsynlighed for, at du ikke scorer særlig godt. Det er det samme for et netværk: første gang det ser dataene og laver en forudsigelse, vil resultatet ikke stemme perfekt overens med de faktiske data.

For at forbedre sin viden bruger netværket en optimizer. I denne analogi kan en optimizer betragtes som at genlæse kapitlet. Du får nye indsigter ved at læse igen. På samme måde bruger netværket optimizeren, opdaterer sin viden og tester den nye viden for at kontrollere, hvor meget det stadig skal lære. Programmet gentager dette trin, indtil det lavest mulige fejl.

I analogien med matematikproblemer betyder det, at du læser lærebogskapitlet mange gange, indtil du fuldt ud forstår kursusindholdet. Selv efter at have læst det flere gange, hvis du bliver ved med at lave en fejl, betyder det, at du har nået den videnskapacitet, der er angivet i 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 holder op med at falde, og tabskurven bliver flad, kan den nuværende arkitektur ikke lære noget andet. Netværket skal optimeres bedre for at forbedre viden.

Disse fire objekter knyttes direkte til de komponenter, du konfigurerer, når du designer et netværk.

Neural Network Architecture

Arkitekturen for kunstige neurale netværk 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 sidder et vilkårligt antal neuroner, der hver har sin egen vægt. Et typisk neuralt netværk behandles ofte af tæt forbundne lag (også kaldet fuldt forbundne lag). Det betyder, at alle input er forbundet med output.

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

Netværket modtager et input, sender det til alle tilsluttede noder og beregner signalet med en aktiveringsfunktion. Det nummererede diagram nedenfor udvider en enkelt node, så du kan se den vægtede sum og aktiveringstrinnet separat.

Figuren ovenfor viser denne idé. Det første lag indeholder inputværdierne. Det andet lag, kaldet det skjulte lag, modtager det vægtede input fra det foregående lag.

1. Den første node er inputværdierne.
2. Neuronen er opdelt i inputdelen og aktiveringsfunktionen. Den venstre del modtager alt input fra det foregående lag. Den højre del er summen af ​​det input, der sendes ind i en aktiveringsfunktion.
3. Outputværdi beregnet ud fra de skjulte lag og brugt til at lave en forudsigelse. Ved klassificering er den lig med antallet af klasser. Ved regression forudsiges kun én værdi.

Aktivering funktion

Aktiveringsfunktionen for en node definerer outputtet givet et sæt input. Du skal bruge en aktiveringsfunktion for at tillade netværket at lære ikke-lineære mønstre. En almindelig aktiveringsfunktion er ReLU, den rektificerede lineære enhed. Funktionen giver et nul for alle negative værdier.

De andre aktiveringsfunktioner er:

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

Diagrammet nedenfor viser, hvorfor ReLU beskrives på den måde: kurven er flad ved nul for hvert negativt input og stiger lineært bagefter.

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 mange lag og skjulte enheder kan lære en kompleks repræsentation af dataene, men de gør netværkets beregninger meget dyre.

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. lineær 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. Optimeringsfunktionen vil hjælpe med at forbedre netværkets vægte for at mindske tabet. Der findes forskellige optimeringsfunktioner, men den mest almindelige er Stokastisk Gradient Descent.

De konventionelle optimeringsværktøjer er:

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

ArchiTekstur alene garanterer ikke en brugbar model.

Begrænsninger af neurale netværk

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

overfitting

Et almindeligt problem med et komplekst neuralt netværk er vanskeligheden ved at generalisere til usete data. Et neuralt netværk med mange vægte kan identificere specifikke detaljer i togsættet meget godt, men det 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 være i stand til at generalisere sådanne mønstre til aldrig før sete data.

Der er en afvejning i machine learning mellem optimering og generalisering.

• Optimering af en model kræver, at man finder 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 indfange specifikke detaljer eller uønskede mønstre i træningsdataene, kan du bruge forskellige teknikker. Den bedste metode er at have et afbalanceret datasæt med en tilstrækkelig mængde data. Kunsten at reducere overfitting kaldes regularisering. De tre teknikker nedenfor er de konventionelle udgangspunkter.

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 modellens kompleksitet på er at reducere dens størrelse. Der er ingen enkelt bedste praksis for at definere antallet af lag. Du skal starte med et lille antal lag og øge størrelsen, indtil du finder ud af, at modellen overfits.

Vægtregulering

En standardteknik til at forhindre overfitting er at tilføje begrænsninger til netværkets vægte. Begrænsningen tvinger netværkets vægte til kun at antage små værdier. Begrænsningen lægges til fejlens tabsfunktion. Der er to former for regularisering:

• L1 (Lasso): omkostningerne er proportionale med den absolutte værdi af vægtkoefficienterne.
• L2 (Kam): omkostningerne er proportionale med kvadratet af værdien af ​​vægtkoefficienterne.

Droppe ud

Dropout er en mærkelig, men nyttig teknik. Et netværk med dropout betyder, at nogle enheder vil blive tilfældigt slukket under et træningstrin, så deres udgående signal bliver nul. Forestil dig, at du har et array af vægte [0.1, 1.7, 0.7, -0.9]. Hvis det neurale netværk har et dropout, vil det blive [0.1, 0, 0, -0.9] med tilfældigt fordelt 0. Parameteren, der styrer dropout'et, er dropout-raten. Hastigheden definerer, hvor mange enheder der er slukket. Det er almindeligt at have en rate mellem 0.2 og 0.5.

Et lille interaktivt eksempel gør træningsløkken nem at se.

Eksempel på neuralt netværk i TensorFlow

Her er et eksempel på et kunstigt neuralt netværk i aktion, der viser, hvordan et neuralt netværk fungerer på et typisk klassifikationsproblem. Der er to input, x1 og x2, hver med en tilfældig værdi. Outputtet er en binær klasse. Målet er at klassificere etiketten baseret på de to funktioner. For at udføre denne opgave er det neurale netværks arkitektur defineret som følger:

• 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ægtene i løbet af 180 epoker med en batchstørrelse på 10. I ANN-eksemplet nedenfor kan du se, hvordan vægtene udvikler sig over tid, og hvordan netværket forbedrer klassifikationskortet.ping.

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

• Med de tilfældige vægte, det vil sige 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 betegnelser, og de orange er de negative betegnelser.

Inde i det andet skjulte lag er linjerne farvet efter vægtenes tegn. De orange linjer har negative vægte, og de blå har positive vægte.

Som du kan se, på outputkortetping, netværket laver en hel del fejl. Se nu på, 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 at klassificere datapunkterne. Sammenlignet med billedet før var den oprindelige vægtning -0.43, mens den efter optimering resulterer i en vægtning på -0.95.

Ideen kan generaliseres til netværk med flere skjulte lag og neuroner. Du kan selv eksperimentere med indstillingerne i TensorFlow Legeplads.

Gennemgangen nedenfor bygger den samme idé i kode mod et rigtigt datasæt.

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

Her er en trin-for-trin-proces til, hvordan man træner et neuralt netværk med TensorFlow ANN ved hjælp af API'ens 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 præcis det samme ud som i de foregående vejledninger. Du skal fortsætte som følger:

1. Importer dataene
2. Transformér dataene
3. Konstruer tensoren
4. Byg modellen
5. Træn og evaluer modellen
6. Forbedre modellen

Versionsnotat: Koden i denne gennemgang er rettet mod TensorFlow 1.x Estimator API'en. Den endelige udgivelse af tf-estimator-pakken blev leveret med TensorFlow 2.15, og tf.estimator blev fjernet i TensorFlow 2.16. For at køre disse trin på en nuværende udgivelse skal du enten fastlåse TensorFlow 2.15 eller genopbygge det samme tolagsnetværk med tf.keras.layers.Dense og model.fit().

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-lære som vist i eksemplet med TensorFlow Neural Network nedenfor.

MNIST-datasættet er det datasæt, der oftest bruges til at teste nye teknikker eller algoritmer. Det er en samling af billeder på 28×28 pixels, der hver viser et håndskrevet ciffer fra 0 til 9. En komité af dybe foldningsnetværk, der er trænet med elastiske forvrængninger, bragte testfejlen ned til 0.27 procent.

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

Den oprindelige gennemgang downloadede MNIST-filerne manuelt og pegede fetch_mldata på den mappe.

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)

API-bemærkning: mldata.org er ikke længere online, og fetch_mldata blev fjernet i scikit-learn 0.22. I en nuværende installation skal ovenstående kald erstattes med fetch_openml('mnist_784', version=1), som downloader de samme 70,000 cifre og eksponerer de identiske data og målattributter.

Derefter opdeler 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 vejledning lærte du, at du skal transformere dataene for at begrænse effekten af ​​outliers. I denne vejledning om neurale netværk vil du transformere dataene ved hjælp af min-max-skalaen. Formlen er:

(X-min_x)/(max_x - min_x)

scikit-learn har allerede 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 oprette tensorer 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

Arkitekturen i det neurale netværk indeholder 2 skjulte lag med 300 enheder for det første lag og 100 enheder for det andet. Disse værdier kommer fra erfaring snarere end fra en formel. Du kan justere dem og se, hvordan de påvirker netværkets nøjagtighed.

For at bygge modellen bruger du estimatoren DNNClassifier. 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 feature_columns, n_classes og model_dir er præcis de samme som i den forrige vejledning. Argumentet hidden_units er det nye: det styrer både antallet af lag og hvor mange noder hvert lag forbinder til det neurale netværk. I koden nedenfor er der to skjulte lag, det første forbinder 300 noder og det andet 100 noder.

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

• funktionskolonner: Definer de kolonner, der skal bruges i netværket
• skjulte_enheder: Definer antallet af skjulte neuroner
• n_klasser: Definer antallet af klasser, der skal forudsiges
• model_mappe: 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-inputfunktionen 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å cirka 96 procent.

Trin 6) Forbedre modellen

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

Her bruger estimatoren en Proximal AdaGrad-optimerer med en frafaldsrate på 0.3 og både L1- og L2-styrker indstillet til 0.01. I et TensorFlow neuralt netværk når du optimizeren gennem togobjektet efterfulgt af navnet på optimizeren. TensorFlow leverer en indbygget API til den Proximal AdaGrad-optimerer.

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

• Læringshastighed: learning_rate
• L1-regularisering: l1_regulariseringsstyrke
• L2-regularisering: l2_regulariseringsstyrke

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 værdier, der blev valgt for at reducere overtilpasningen, forbedrede ikke modellens nøjagtighed. Din første model havde en nøjagtighed på 96 %, mens modellen med L2-regularisatoren har en nøjagtighed på 95 %. Du kan prøve forskellige værdier og se, hvordan de påvirker nøjagtigheden.

Ofte Stillede Spørgsmål